5b809628bd9f82adfa44ad1dba84576622ba7b67-PR-141

Committed 09 Apr 2024 12:53AM UTC coverage: 21.597% (+0.03%) from 21.565%

Build # 5b809628bd9f82adfa44ad1dba84576622ba7b67-PR-141

Build Type

Pull #141

github

Committed by

web-flow

Commit Message

Merge d4a81dee2 into 01c841715

Pull Request Pull Request #141: Fix #140

Run Details

20 of 25 new or added lines in 1 file covered. (80.0%)

32 existing lines in 2 files now uncovered.

13184 of 61046 relevant lines covered (21.6%)

15717.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

30.93

/api_utils.go

package tensor

import (
        "math"
        "math/rand"
        "reflect"
        "sort"

        "github.com/chewxy/math32"
)

// SortIndex: Similar to numpy's argsort.
// Returns indices for sorting a slice in increasing order.
// Input slice remains unchanged.
// SortIndex may not be stable; for stability, use SortIndexStable.
func SortIndex(in interface{}) (out []int) {
        return sortIndex(in, sort.Slice)
}

// SortIndexStable: Similar to SortIndex, but stable.
// Returns indices for sorting a slice in increasing order.
// Input slice remains unchanged.
func SortIndexStable(in interface{}) (out []int) {
        return sortIndex(in, sort.SliceStable)
}

func sortIndex(in interface{}, sortFunc func(x interface{}, less func(i int, j int) bool)) (out []int) {
        switch list := in.(type) {
        case []int:
                out = make([]int, len(list))
                for i := 0; i < len(list); i++ {
                        out[i] = i
                }
                sortFunc(out, func(i, j int) bool {
                        return list[out[i]] < list[out[j]]
                })
        case []float64:
                out = make([]int, len(list))
                for i := 0; i < len(list); i++ {
                        out[i] = i
                }
                sortFunc(out, func(i, j int) bool {
                        return list[out[i]] < list[out[j]]
                })
        case sort.Interface:
                out = make([]int, list.Len())
                for i := 0; i < list.Len(); i++ {
                        out[i] = i
                }
                sortFunc(out, func(i, j int) bool {
                        return list.Less(out[i], out[j])
                })
        default:
                panic("The slice type is not currently supported.")
        }

        return
}

// SampleIndex samples a slice or a Tensor.
// TODO: tidy this up.
func SampleIndex(in interface{}) int {
        // var l int
        switch list := in.(type) {
        case []int:
                var sum, i int
                // l = len(list)
                r := rand.Int()
                for {
                        sum += list[i]
                        if sum > r && i > 0 {
                                return i
                        }
                        i++
                }
        case []float64:
                var sum float64
                var i int
                // l = len(list)
                r := rand.Float64()
                for {
                        sum += list[i]
                        if sum > r && i > 0 {
                                return i
                        }
                        i++
                }
        case *Dense:
                var i int
                switch list.t.Kind() {
                case reflect.Float64:
                        var sum float64
                        r := rand.Float64()
                        data := list.Float64s()
                        // l = len(data)
                        for {
                                datum := data[i]
                                if math.IsNaN(datum) || math.IsInf(datum, 0) {
                                        return i
                                }

                                sum += datum
                                if sum > r && i > 0 {
                                        return i
                                }
                                i++
                        }
                case reflect.Float32:
                        var sum float32
                        r := rand.Float32()
                        data := list.Float32s()
                        // l = len(data)
                        for {
                                datum := data[i]
                                if math32.IsNaN(datum) || math32.IsInf(datum, 0) {
                                        return i
                                }

                                sum += datum
                                if sum > r && i > 0 {
                                        return i
                                }
                                i++
                        }
                default:
                        panic("not yet implemented")
                }
        default:
                panic("Not yet implemented")
        }
        return -1
}

1	package tensor
2
3	import (
4	"math"
5	"math/rand"
6	"reflect"
7	"sort"
8
9	"github.com/chewxy/math32"
10	)
11
12	// SortIndex: Similar to numpy's argsort.
13	// Returns indices for sorting a slice in increasing order.
14	// Input slice remains unchanged.
15	// SortIndex may not be stable; for stability, use SortIndexStable.
16	func SortIndex(in interface{}) (out []int) {	6✔
17	return sortIndex(in, sort.Slice)	6✔
18	}	6✔
19
20	// SortIndexStable: Similar to SortIndex, but stable.
21	// Returns indices for sorting a slice in increasing order.
22	// Input slice remains unchanged.
NEW 23	func SortIndexStable(in interface{}) (out []int) {	×
NEW 24	return sortIndex(in, sort.SliceStable)	×
NEW 25	}	×
26
27	func sortIndex(in interface{}, sortFunc func(x interface{}, less func(i int, j int) bool)) (out []int) {	6✔
28	switch list := in.(type) {	6✔
29	case []int:	2✔
30	out = make([]int, len(list))	2✔
31	for i := 0; i < len(list); i++ {	32✔
32	out[i] = i	30✔
33	}	30✔
34	sortFunc(out, func(i, j int) bool {	86✔
35	return list[out[i]] < list[out[j]]	84✔
36	})	84✔
37	case []float64:	2✔
38	out = make([]int, len(list))	2✔
39	for i := 0; i < len(list); i++ {	32✔
40	out[i] = i	30✔
41	}	30✔
42	sortFunc(out, func(i, j int) bool {	110✔
43	return list[out[i]] < list[out[j]]	108✔
44	})	108✔
45	case sort.Interface:	2✔
46	out = make([]int, list.Len())	2✔
47	for i := 0; i < list.Len(); i++ {	32✔
48	out[i] = i	30✔
49	}	30✔
50	sortFunc(out, func(i, j int) bool {	86✔
51	return list.Less(out[i], out[j])	84✔
52	})	84✔
NEW 53	default:	×
NEW 54	panic("The slice type is not currently supported.")	×
55	}
56
57	return	6✔
58	}
59
60	// SampleIndex samples a slice or a Tensor.
61	// TODO: tidy this up.
62	func SampleIndex(in interface{}) int {	×
63	// var l int	×
64	switch list := in.(type) {	×
65	case []int:	×
66	var sum, i int	×
67	// l = len(list)	×
68	r := rand.Int()	×
69	for {	×
70	sum += list[i]	×
71	if sum > r && i > 0 {	×
72	return i	×
73	}	×
74	i++	×
75	}
76	case []float64:	×
77	var sum float64	×
78	var i int	×
79	// l = len(list)	×
80	r := rand.Float64()	×
81	for {	×
82	sum += list[i]	×
83	if sum > r && i > 0 {	×
84	return i	×
85	}	×
86	i++	×
87	}
88	case *Dense:	×
89	var i int	×
90	switch list.t.Kind() {	×
91	case reflect.Float64:	×
92	var sum float64	×
93	r := rand.Float64()	×
94	data := list.Float64s()	×
95	// l = len(data)	×
96	for {	×
97	datum := data[i]	×
98	if math.IsNaN(datum) \|\| math.IsInf(datum, 0) {	×
99	return i	×
100	}	×
101
102	sum += datum	×
103	if sum > r && i > 0 {	×
104	return i	×
105	}	×
106	i++	×
107	}
108	case reflect.Float32:	×
109	var sum float32	×
110	r := rand.Float32()	×
111	data := list.Float32s()	×
112	// l = len(data)	×
113	for {	×
114	datum := data[i]	×
115	if math32.IsNaN(datum) \|\| math32.IsInf(datum, 0) {	×
116	return i	×
117	}	×
118
119	sum += datum	×
120	if sum > r && i > 0 {	×
121	return i	×
122	}	×
123	i++	×
124	}
125	default:	×
126	panic("not yet implemented")	×
127	}
128	default:	×
129	panic("Not yet implemented")	×
130	}
131	return -1	×
132	}

gorgonia / tensor / 5b809628bd9f82adfa44ad1dba84576622ba7b67-PR-141

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous