<转> Spark 线性代数库 Breeze API 详解_breeze库中的meanandvariance参数-优快云博客

本文详细介绍了使用Breeze库进行各种数值计算的方法，包括向量和矩阵的基本运算、统计计算、数学函数应用以及一个逻辑回归的模拟示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转载请标明出处：小帆的帆的专栏

运算

加，减，乘，除

向量与向量

加：+
减：-
乘：:*
除：:/

规则1:乘除前面，加冒号；单独的乘号和除号分别表示点积和线性求解
规则2:累加效果，加等号

import breeze.linalg.DenseVector

object Test {
  def main(args: Array[String]) {
    val v1 = DenseVector(1.0, 2.0, 3.0, 4.0)
    val v2 = DenseVector(0.5, 0.5, 0.5, 0.5)
    // DenseVector(1.5, 2.5, 3.5, 4.5)
    println("\nv1 + v2 : ")
    println(v1 + v2)

    // DenseVector(0.5, 1.5, 2.5, 3.5)
    println("\nv1 - v2 : ")
    println(v1 - v2)

    // DenseVector(0.5, 1.0, 1.5, 2.0)
    println("\nv1 :* v2 : ")
    // 规则1：乘号前面多了冒号
    println(v1 :* v2)

    // DenseVector(2.0, 4.0, 6.0, 8.0)
    println("\nv1 :/ v2 : ")
    // 规则1：除号前面多了冒号
    println(v1 :/ v2)

    // 但是v1 和 v2并没有改变
    // DenseVector(1.0, 2.0, 3.0, 4.0)
    println("\nv1 : ")
    println(v1)

    // DenseVector(0.5, 0.5, 0.5, 0.5)
    println("\nv2 : ")
    println(v2)

    // 规则2
    // 如果想把最后的结果保存到v1上，需要加等号
    // DenseVector(1.5, 2.5, 3.5, 4.5)
    println("\nv1 += v2 : ")
    println(v1 += v2)

    // DenseVector(1.0, 2.0, 3.0, 4.0)
    println("\nv1 -= v2 : ")
    println(v1 -= v2)

    // DenseVector(0.5, 1.0, 1.5, 2.0)
    println("\nv1 :*= v2 : ")
    // 注意：乘号前面多了冒号
    println(v1 :*= v2)

    // DenseVector(1.0, 2.0, 3.0, 4.0)
    println("\nv1 :/= v2 : ")
    // 注意：除号前面多了冒号
    println(v1 :/= v2)
  }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

矩阵与矩阵

跟向量与向量完全一样

加：+
减：-
乘：:*
除：:/

规则1:乘除前面，加冒号；单独的乘号和除号分别表示点积和线性求解
规则2:累加效果，加等号

import breeze.linalg.DenseMatrix

object Test1 {
  def main(args: Array[String]) {
    val m1 = DenseMatrix((1.0, 2.0), (3.0, 4.0))
    val m2 = DenseMatrix((0.5, 0.5), (0.5, 0.5))

    /**
      * 1.5  2.5  
      * 3.5  4.5
      */
    println("\nm1 + m2 : ")
    println(m1 + m2)

    /**
      * 0.5  1.5  
      * 2.5  3.5  
      */
    println("\nm1 - m2 : ")
    println(m1 - m2)

    /**
      * 0.5  1.0  
      * 1.5  2.0  
      */
    println("\nm1 :* m2 : ")
    // 注意：乘号前面多了冒号
    println(m1 :* m2)

    /**
      * 2.0  4.0  
      * 6.0  8.0  
      */
    println("\nm1 :/ m2 : ")
    // 注意：除号前面多了冒号
    println(m1 :/ m2)

    // 但是m1 和 m2并没有改变
    /**
      * 1.0  2.0  
      * 3.0  4.0  
      */
    println("\nm1 : ")
    println(m1)

    /**
      * 0.5  0.5  
      * 0.5  0.5  
      */
    println("\nm2 : ")
    println(m2)

    // 如果想把最后的结果保存到m1上，需要加等号
    /**
      * 1.5  2.5  
      * 3.5  4.5
      */
    println("\nm1 += m2 : ")
    println(m1 += m2)

    /**
      * 1.0  2.0  
      * 3.0  4.0  
      */
    println("\nm1 -= m2 : ")
    println(m1 -= m2)

    /**
      * 0.5  1.0  
      * 1.5  2.0  
      */
    println("\nm1 :*= m2 : ")
    // 注意：乘号前面多了冒号
    println(m1 :*= m2)

    /**
      * 1.0  2.0  
      * 3.0  4.0  
      */
    println("\nm1 :/= m2 : ")
    // 注意：除号前面多了冒号
    println(m1 :/= m2)
  }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

矩阵或向量与数值

加：+
减：-
乘：*
除：/

规则1:累加效果，加等号

注意：乘除号前不需要冒号，因为没有矩阵与数值的点积等计算

import breeze.linalg.{DenseMatrix, DenseVector}

object Test1 {
  def main(args: Array[String]) {
    val v1 = DenseVector(1.0, 2.0, 3.0, 4.0)

    // DenseVector(1.5, 2.5, 3.5, 4.5)
    println("v1 + 0.5 : ")
    println(v1 + 0.5)

    // DenseVector(0.5, 1.5, 2.5, 3.5)
    println("\nv1 - 0.5 : ")
    println(v1 - 0.5)

    // DenseVector(0.5, 1.0, 1.5, 2.0)
    println("\nv1 * 0.5 : ")
    println(v1 * 0.5)

    // DenseVector(2.0, 4.0, 6.0, 8.0)
    println("\nv1 / 0.5 : ")
    println(v1 / 0.5)

    // v1依然不变
    // DenseVector(1.0, 2.0, 3.0, 4.0)
    println("\nv1 : ")
    println(v1)

    // DenseVector(1.5, 2.5, 3.5, 4.5)
    println("\nv1 += 0.5 : ")
    println(v1 += 0.5)

    // DenseVector(1.0, 2.0, 3.0, 4.0)
    println("\nv1 -= 0.5 : ")
    println(v1 -= 0.5)

    // DenseVector(0.5, 1.0, 1.5, 2.0)
    println("\nv1 *= 0.5 : ")
    println(v1 *= 0.5)

    // DenseVector(5.0, 10.0, 15.0, 20.0)
    println("\nv1 /= 0.1 : ")
    println(v1 /= 0.1)

    // DenseVector(5.0, 10.0, 15.0, 20.0)
    println("\nv1 : ")
    println(v1)

    val m1 = DenseMatrix((1.0, 2.0), (3.0, 4.0))

    /**
      * 1.5  2.5  
      * 3.5  4.5  
      */
    println("m1 + 0.5 : ")
    println(m1 + 0.5)

    /**
      * 0.5  1.5  
      * 2.5  3.5  
      */
    println("\nm1 - 0.5 : ")
    println(m1 - 0.5)

    /**
      * 0.5  1.0  
      * 1.5  2.0  
      */
    println("\nm1 * 0.5 : ")
    println(m1 * 0.5)

    /**
      * 2.0  4.0  
      * 6.0  8.0  
      */
    println("\nm1 / 0.5 : ")
    println(m1 / 0.5)

    // m1依然不变
    /**
      * 1.0  2.0  
      * 3.0  4.0  
      */
    println("\nm1 : ")
    println(m1)

    /**
      * 1.5  2.5  
      * 3.5  4.5  
      */
    println("\nm1 += 0.5 : ")
    println(m1 += 0.5)

    /**
      * 1.0  2.0  
      * 3.0  4.0  
      */
    println("\nm1 -= 0.5 : ")
    println(m1 -= 0.5)

    /**
      * 0.5  1.0  
      * 1.5  2.0  
      */
    println("\nm1 *= 0.5 : ")
    println(m1 *= 0.5)

    /**
      * 5.0   10.0  
      * 15.0  20.0 
      */
    println("\nm1 /= 0.1 : ")
    println(m1 /= 0.1)

    /**
      * 5.0   10.0  
      * 15.0  20.0  
      */
    println("\nm1 : ")
    println(m1)
  }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

矩阵与向量

加：+
减：-
乘：:*
除：:/

规则1:乘除前面，加冒号；单独的乘号和除号分别表示点积和线性求解
规则2:累加效果，加等号
规则3:必须有星号
规则4:星号在左，逐行；星号在右，逐列；与向量是列向量还是行向量无关
规则5:向量必须是列向量

import breeze.linalg.{*, DenseMatrix, DenseVector}

object Test1 {
  def main(args: Array[String]) {

    val m1 = DenseMatrix(
      (1.0, 2.0),
      (3.0, 4.0)
    )

    val v1 = DenseVector(1.0, 2.0)
    //    val v1 = DenseVector(1.0, 2.0).t // 运行时异常，规则5，向量必须是列向量
    //    val v1 = DenseVector(1.0, 2.0).t.t // 正确，如果是一个列向量，需要转换成行向量

    // 规则4: 星号在左，逐行；星号在右，逐列
    println("-------------星号在左边，就逐行操作-----------------")

    /**
      * 2.0  4.0
      * 4.0  6.0
      */
    println("\nm1(*, ::) + v1 : ")
    println(m1(*, ::) + v1)

    /**
      * 0.0  0.0
      * 2.0  2.0
      */
    println("\nm1(*, ::) - v1 : ")
    println(m1(*, ::) - v1)

    //    规则1: 乘除前面，加冒号

    /**
      * 1.0  4.0
      * 3.0  8.0
      */
    println("\nm1(*, ::) :* v1 : ")
    println(m1(*, ::) :* v1)

    /**
      * 1.0  1.0
      * 3.0  2.0
      */
    println("\nm1(*, ::) :/ v1 : ")
    println(m1(*, ::) :/ v1)

    println("-------------星号在右边，就逐列操作-----------------")

    /**
      * 2.0  3.0
      * 5.0  6.0
      */
    println("\nm1(::, *) + v1 : ")
    println(m1(::, *) + v1)

    /**
      * 0.0  1.0
      * 1.0  2.0
      */
    println("\nm1(::, *) - v1 : ")
    println(m1(::, *) - v1)

    /**
      * 1.0  2.0
      * 6.0  8.0
      */
    println("\nm1(::, *) :* v1 : ")
    println(m1(::, *) :* v1)

    /**
      * 1.0  2.0
      * 1.5  2.0
      */
    println("\nm1(::, *) :/ v1 : ")
    println(m1(::, *) :/ v1)

    // 无论星号在哪，m1都不会改变
    println("-------------规则2: 累加效果，加等号-----------------")

    // 下面以整除为例，注意星号的位置，一个在左，一个在右

    /**
      * 1.0  2.0
      * 3.0  4.0
      */
    println("\nm1 : ")
    println(m1)

    /**
      * BroadcastedRows(1.0  4.0
      * 3.0  8.0  )
      */
    println("\nm1(*, ::) :*= v1 : ")
    println(m1(*, ::) :*= v1)

    /**
      * 1.0  4.0
      * 3.0  8.0
      */
    println("\nm1 : ")
    println(m1)

    /**
      * BroadcastedColumns(1.0  4.0
      * 1.5  4.0  )
      */
    println("\nm1(::, *) :/= v1 : ")
    println(m1(::, *) :/= v1)

    /**
      * 1.0  4.0
      * 1.5  4.0
      */
    println("\nm1 : ")
    println(m1)
  }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

函数

统计

求和

import breeze.linalg.{Axis, DenseMatrix, sum}

object Test1 {
  def main(args: Array[String]) {

    val m1 = DenseMatrix(
      (1.0, 2.0),
      (3.0, 4.0)
    )

    // Axis._0 纵向
    // 4.0  6.0
    println(sum(m1, Axis._0))

    // Axis._1 横向
    // 3.0 7.0
    println(sum(m1, Axis._1))
  }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

均值

import breeze.linalg.{Axis, DenseMatrix}
import breeze.stats.mean

object Test1 {
  def main(args: Array[String]) {

    val m1 = DenseMatrix(
      (1.0, 2.0),
      (3.0, 4.0)
    )

    // Axis._0 纵向
    // 4.0  6.0
    println(mean(m1, Axis._0))

    // Axis._1 横向
    // 1.5  3.5
    println(mean(m1, Axis._1))
  }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

方差和标准差

import breeze.linalg.{Axis, DenseMatrix}
import breeze.stats.{stddev, variance}

object Test1 {
  def main(args: Array[String]) {

    val m1 = DenseMatrix(
      (1.0, 2.0),
      (3.0, 4.0)
    )

    // Axis._0 纵向
    // 2.0  2.0 
    println(variance(m1, Axis._0))

    // Axis._1 横向
    // 0.5, 0.5
    println(variance(m1, Axis._1))

    // Axis._0 纵向
    // 2.0  2.0 
    println(stddev(m1, Axis._0))

    // Axis._1 横向
    // 0.5, 0.5
    println(stddev(m1, Axis._1))
  }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

N次方和开方

import breeze.linalg.DenseMatrix
import breeze.numerics.{pow, sqrt}

object Test1 {
  def main(args: Array[String]) {

    val m1 = DenseMatrix(
      (1.0, 2.0),
      (3.0, 4.0)
    )

    /**
      * 1.0  4.0
      * 9.0  16.0
      */
    println(pow(m1, 2))

    /**
      * 1.0   8.0   
      * 27.0  64.0  
      */
    println(pow(m1, 3))

    /**
      * 1.0                 1.4142135623730951  
      * 1.7320508075688772  2.0  
      */
    println(sqrt(m1))
  }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

E和log

import breeze.linalg.DenseMatrix
import breeze.numerics.{exp, log, log10, log1p}

object Test1 {
  def main(args: Array[String]) {

    val m1 = DenseMatrix(
      (1.0, 2.0),
      (3.0, 4.0)
    )

    /**
      * 2.718281828459045   7.38905609893065
      * 20.085536923187668  54.598150033144236
      */
    // e = 2.718281828459045
    println(exp(m1))

    /**
      * 0.0                 0.6931471805599453
      * 1.0986122886681098  1.3862943611198906
      */
    // 以e为底
    println(log(m1))

    /**
      * 0.0                  0.3010299956639812  
      * 0.47712125471966244  0.6020599913279624  
      */
    // 以10为底
    println(log10(m1))

    /**
      * 0.6931471805599453  1.0986122886681096  
      * 1.3862943611198906  1.6094379124341003  
      */
    // 以e为底
    // log1p() 以返回 log(1 + x)，甚至当 x 的值接近零也能计算出准确结果。
    println(log1p(m1))
  }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

三角

sin, sinh, asin, asinh
cos, cosh, acos, acosh
tan, tanh, atan, atanh
atan2
sinc(x) == sin(x)/x
sincpi(x) == sinc(x * Pi)

取整

import breeze.linalg.DenseVector
import breeze.numerics._

object Test1 {
  def main(args: Array[String]) {
    val a = DenseVector(1.4, 0.5, -2.3)

    // 四舍五入
    println(round(a))

    // 向上取整
    println(ceil(a))

    // 向下取整
    println(floor(a))

    // 大于0，为1；小于0，为-1
    println(signum(a))

    // 绝对值
    println(abs(a))
  }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

示例

模拟逻辑回归

利用Breze进行，归一化，添加截距项，预测

import breeze.linalg._
import breeze.numerics._
import breeze.stats._

object Work2 {
  def main(args: Array[String]) {

    // 随机产生数据
    //    val featuresMatrix = DenseMatrix.rand[Double](3, 3)
    //    val labelMatrix = DenseMatrix.rand[Double](3, 1)

    // 测试数据
    val featuresMatrix = DenseMatrix(
      (1.0, 2.0, 3.0),
      (4.0, 5.0, 6.0),
      (7.0, 8.0, 9.0)
    )

    val labelMatrix = DenseMatrix(
      1.0,
      1.0,
      0.0
    )

    // 均值
    // DenseVector(4.0, 5.0, 6.0)
    val featuresMean = mean(featuresMatrix(::, *)).toDenseVector
    println("均值：")
    println(featuresMean)

    // 标准差
    // DenseVector(3.0, 3.0, 3.0)
    val featuresStddev = stddev(featuresMatrix(::, *)).toDenseVector
    println("\n标准差：")
    println(featuresStddev)

    // 减去均值
    /**
      * -3.0  -3.0  -3.0
      * 0.0   0.0   0.0
      * 3.0   3.0   3.0
      */
    featuresMatrix(*, ::) -= featuresMean
    println("\n减去均值：")
    println(featuresMatrix)

    // 除以标准差
    /**
      * -1.0  -1.0  -1.0
      * 0.0   0.0   0.0
      * 1.0   1.0   1.0
      */
    featuresMatrix(*, ::) /= featuresStddev
    println("\n除以标准差：")
    println(featuresMatrix)

    // 生成截距
    /**
      * 1.0
      * 1.0
      * 1.0
      */
    val intercept = DenseMatrix.ones[Double](featuresMatrix.rows, 1)
    println("\n截距：")
    println(intercept)

    // 拼接成为最终的训练集
    /**
      * 1.0  -1.0  -1.0  -1.0
      * 1.0  0.0   0.0   0.0
      * 1.0  1.0   1.0   1.0
      */
    val train = DenseMatrix.horzcat(intercept, featuresMatrix)
    println("\n训练集：")
    println(train)

    // 参数
    // 为方便检查结果，这里全部设置为1
    /**
      * 1.0
      * 1.0
      * 1.0
      * 1.0
      */
    val w = new DenseMatrix(4, 1, Array(1.0, 1.0, 1.0, 1.0))
    //    val w = DenseMatrix.rand[Double](4, 1) // 随机生成, 一定要指定类型
    println("\n参数：")
    println(w)

    /**
      * -2.0
      * 1.0
      * 4.0
      */
    // 随机生成w时，如果没有指定类型，A的计算结果虽然不会有错，但是后面将无法计算，除非通过asInstanceOf进行类型转换
    // 如果w指定了类型，那么在idea中，转换语句会是灰色的，意思是这句话没有作用，可以不写
    val A = (train * w).asInstanceOf[DenseMatrix[Double]]
    println("\nA：")
    println(A)

    /**
      * 0.11920292202211755
      * 0.7310585786300049
      * 0.9820137900379085
      */
    // Sigmoid函数
    val probability = 1.0 / (exp(A * -1.0) + 1.0)
    println("\nprobability：")
    println(probability)

    /**
      * MSE : 0.6041613548425021
      */
    val MSE = mean(pow(probability - labelMatrix, 2))
    println("\nMSE：")
    println(MSE)

    /**
      * RMSE : 0.777278170825929
      */
    val RMSE = sqrt(MSE)
    println("\nRMSE：")
    println(RMSE)
  }

}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126