/
max.go
120 lines (100 loc) · 1.89 KB
/
max.go
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
package functions
func AddSampleMax(a, b interface{}) interface{} {
if a == nil {
return b
} else if b == nil {
return a
}
switch x := a.(type) {
case int:
if x > b.(int) {
return a
}
return b
case float64:
if x > b.(float64) {
return a
}
return b
case []int:
y := b.([]int)
for idx, value := range x {
if y[idx] > value {
x[idx] = y[idx]
}
}
return x
case []float64:
y := b.([]float64)
for idx, value := range x {
if y[idx] > value {
x[idx] = y[idx]
}
}
return x
}
panic("invalid input")
}
func AggregateBlocksMax(blocks []interface{}, start int, size int) interface{} {
switch blocks[0].(type) {
case int:
return maxInt(blocks)
case float64:
return maxFloat(blocks)
case []int:
return maxIntArray(blocks)
case []float64:
return maxFloatArray(blocks)
}
//todo handle unsupported type
return 0
}
func AggregateBlocksCount(blocks []interface{}, start int, size int) interface{} {
return len(blocks)
}
func maxInt(blocks []interface{}) interface{} {
max := blocks[0].(int)
for _, block := range blocks {
if block.(int) > max {
max = block.(int)
}
}
return max
}
func maxFloat(blocks []interface{}) interface{} {
max := blocks[0].(float64)
for _, block := range blocks {
if block.(float64) > max {
max = block.(float64)
}
}
return max
}
func maxIntArray(blocks []interface{}) interface{} {
firstBlock := blocks[0].([]int)
var max []int
copy(max, firstBlock)
for _, block := range blocks {
arrBlock := block.([]int)
for i, val := range arrBlock {
if val > max[i] {
max[i] = val
}
}
}
return max
}
func maxFloatArray(blocks []interface{}) interface{} {
firstBlock := blocks[0].([]float64)
var max []float64
copy(max, firstBlock)
for _, block := range blocks {
arrBlock := block.([]float64)
for i, val := range arrBlock {
if val > max[i] {
max[i] = val
}
}
}
return max
}