func SliceRandFloat(s []float64) float64 {
	rand.Seed(time.Now().Unix())  
	return s[rand.Intn(len(s))]
}
SliceRandFloat returns a random value from a float64 slice
package gosc
import (
	"fmt"
	"math/rand"
	"reflect"
	"sort"
	"strings"
	"time"
)
func MapString(s []string, f func(string) string) []string {
	sm := make([]string, len(s))
	for i, v := range s {
		sm[i] = f(v)
	}
	return sm
}
func MapInt(s []int, f func(int) int) []int {
	sm := make([]int, len(s))
	for i, v := range s {
		sm[i] = f(v)
	}
	return sm
}
func MapFloat(s []float64, f func(float64) float64) []float64 {
	sm := make([]float64, len(s))
	for i, v := range s {
		sm[i] = f(v)
	}
	return sm
}
func FilterString(s []string, f func(string) bool) []string {
	sf := make([]string, 0)
	for _, v := range s {
		if f(v) {
			sf = append(sf, v)
		}
	}
	return sf
}
func FilterInt(s []int, f func(int) bool) []int {
	sf := make([]int, 0)
	for _, v := range s {
		if f(v) {
			sf = append(sf, v)
		}
	}
	return sf
}
func FilterFloat(s []float64, f func(float64) bool) []float64 {
	sf := make([]float64, 0)
	for _, v := range s {
		if f(v) {
			sf = append(sf, v)
		}
	}
	return sf
}
func AllString(s []string, f func(string) bool) bool {
	for _, v := range s {
		if !f(v) {
			return false
		}
	}
	return true
}
func AllInt(s []int, f func(int) bool) bool {
	for _, v := range s {
		if !f(v) {
			return false
		}
	}
	return true
}
func AllFloat(s []float64, f func(float64) bool) bool {
	for _, v := range s {
		if !f(v) {
			return false
		}
	}
	return true
}
func EveryString(s []string, f func(string) bool) bool {
	for _, v := range s {
		if !f(v) {
			return false
		}
	}
	return true
}
func EveryInt(s []int, f func(int) bool) bool {
	for _, v := range s {
		if !f(v) {
			return false
		}
	}
	return true
}
func EveryFloat(s []float64, f func(float64) bool) bool {
	for _, v := range s {
		if !f(v) {
			return false
		}
	}
	return true
}
func AnyString(s []string, f func(string) bool) bool {
	for _, v := range s {
		if f(v) {
			return true
		}
	}
	return false
}
func AnyInt(s []int, f func(int) bool) bool {
	for _, v := range s {
		if f(v) {
			return true
		}
	}
	return false
}
func AnyFloat(s []float64, f func(float64) bool) bool {
	for _, v := range s {
		if f(v) {
			return true
		}
	}
	return false
}
func SomeString(s []string, f func(string) bool) bool {
	for _, v := range s {
		if f(v) {
			return true
		}
	}
	return false
}
func SomeInt(s []int, f func(int) bool) bool {
	for _, v := range s {
		if f(v) {
			return true
		}
	}
	return false
}
func SomeFloat(s []float64, f func(float64) bool) bool {
	for _, v := range s {
		if f(v) {
			return true
		}
	}
	return false
}
func Index(s interface{}, t interface{}) int {
	sl := reflect.ValueOf(s).Elem()
	if sl.Len() == 0 {
		return -1
	}
	for i := 0; i < sl.Len(); i++ {
		if sl.Index(i).Interface() == t {
			return i
		}
	}
	return -1
}
func Indexi(s []string, t string) int {
	if len(s) == 0 || len(t) == 0 {
		return -1
	}
	for i, v := range s {
		if strings.ToLower(v) == strings.ToLower(t) {
			return i
		}
	}
	return -1
}
func Delete(s interface{}, i int) {
	sl := reflect.ValueOf(s).Elem()
	if i > sl.Len()-1 || sl.Len() == 0 || i < 0 {
		return
	}
	switch s.(type) {
	case *[]string:
		sli := sl.Interface().([]string)
		*s.(*[]string) = append(sli[:i], sli[i+1:]...)
	case *[]int:
		sli := sl.Interface().([]int)
		*s.(*[]int) = append(sli[:i], sli[i+1:]...)
	case *[]float64:
		sli := sl.Interface().([]float64)
		*s.(*[]float64) = append(sli[:i], sli[i+1:]...)
	default:
		return
	}
}
func Rsort(s interface{}) {
	sl := reflect.ValueOf(s).Elem()
	switch s.(type) {
	case *[]string:
		sli := sl.Interface().([]string)
		sort.Sort(sort.Reverse(sort.StringSlice(sli)))
		*s.(*[]string) = sli
	case *[]int:
		sli := sl.Interface().([]int)
		sort.Sort(sort.Reverse(sort.IntSlice(sli)))
		*s.(*[]int) = sli
	case *[]float64:
		sli := sl.Interface().([]float64)
		sort.Sort(sort.Reverse(sort.Float64Slice(sli)))
		*s.(*[]float64) = sli
	default:
		return
	}
}
func ReverseSort(s interface{}) {
	sl := reflect.ValueOf(s).Elem()
	switch s.(type) {
	case *[]string:
		sli := sl.Interface().([]string)
		sort.Sort(sort.Reverse(sort.StringSlice(sli)))
		*s.(*[]string) = sli
	case *[]int:
		sli := sl.Interface().([]int)
		sort.Sort(sort.Reverse(sort.IntSlice(sli)))
		*s.(*[]int) = sli
	case *[]float64:
		sli := sl.Interface().([]float64)
		sort.Sort(sort.Reverse(sort.Float64Slice(sli)))
		*s.(*[]float64) = sli
	default:
		return
	}
}
func EqSlices(a, b interface{}) bool {
	sl1 := reflect.ValueOf(a).Elem()
	sl2 := reflect.ValueOf(b).Elem()
	if a == nil && b == nil {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	if sl1.Len() != sl2.Len() {
		return false
	}
	if fmt.Sprintf("%T", sl1.Interface()) != fmt.Sprintf("%T", sl1.Interface()) {
		return false
	}
	for i := 0; i < sl1.Len(); i++ {
		if sl1.Index(i).Interface() != sl2.Index(i).Interface() {
			return false
		}
	}
	return true
}
func SliceRand(s interface{}, r interface{}) {
	rand.Seed(time.Now().Unix())
	sl := reflect.ValueOf(s).Elem()
	switch s.(type) {
	case *[]string:
		sli := sl.Interface().([]string)
		*r.(*string) = sli[rand.Intn(len(sli))]
	case *[]int:
		sli := sl.Interface().([]int)
		*r.(*int) = sli[rand.Intn(len(sli))]
	case *[]float64:
		sli := sl.Interface().([]float64)
		*r.(*float64) = sli[rand.Intn(len(sli))]
	default:
		return
	}
}
func SliceRandString(s []string) string {
	rand.Seed(time.Now().Unix())  
	return s[rand.Intn(len(s))]
}
func SliceRandS(s []string) string {
	return SliceRandString(s)
}
func SliceRandInt(s []int) int {
	rand.Seed(time.Now().Unix())  
	return s[rand.Intn(len(s))]
}
func SliceRandI(s []int) int {
	return SliceRandInt(s)
}