Сроки на Голанге с и без пустого идентификатора

Question

Я играю с некоторыми элементарными моментами в Go и у меня есть вопрос. Я хочу приурочить Голанга к получению квадратного корня каждого элемента массива, но я получаю два несколько разных ответа независимо от того, сохраняю ли я вывод. Вот моя первая версия:

package main

import ("fmt"
        "time" 
        "math"
        "math/rand"
)

// A random array of integers 
func randomArray(max int ,len int) []int {
    a := make([]int, len)
    for i := 0; i <= len-1; i++ {
        a[i] = rand.Intn(max)
    }
    return a
}

// Taking square root of each element in array
func sqrt_array(arr [] int) [] float64 {
    var len_arr = len(arr)
    a := make([]float64, len_arr)
    for i, v := range arr {
    a[i] = math.Sqrt(float64(v))
    }
    return a
}


func main() {

    arr := randomArray(100, 10e6)
    sqrt := make([]float64, len(arr))
    start := time.Now()
    sqrt = sqrt_array(arr)
    end := time.Now()

    fmt.Println("time taken: ", end.Sub(start), sqrt[0])
}

дает в среднем около 36 мс:

time taken:  36.542019ms 9

Теперь, когда я заменяю вывод "sqrt" пустым идентификатором, я получаю что-то намного медленнее. В частности, я заменяю main () на

func main() {

    arr := randomArray(100, 10e6)
    // sqrt := make([]float64, len(arr))
    start := time.Now()
    _ = sqrt_array(arr)
    end := time.Now()

    fmt.Println("time taken: ", end.Sub(start))
}

и получите в среднем что-то вроде 92 мс

time taken:  92.121481ms

Может ли кто-нибудь объяснить, что происходит? Я чувствую, что если бы я понял, я мог бы кое-что узнать о Go

Между прочим, я нахожу, что те же вычисления в Python составляли около 20 мс при трансляции и несколько сотен мс при зацикливании.

Answer 1

@ Not_a_Golfer, это интересная идея, спасибо! Я заменил sqrt_array на

func sqrt_array(arr [] int) [] float64 {
    var len_arr = len(arr)
    a := make([]float64, len_arr)
    s := time.Now()
    for i, v := range arr {
    a[i] = math.Sqrt(float64(v))
    }
    e := time.Now()
    fmt.Println("time taken: ", e.Sub(s))
    return a
}

и обнаружил, что первая функция main (), которую я использовал, дает:

время: 30.455811мс
время: 36.419998мс 9

в то время как второй дает

время: 30,916246мс
принятое время: 90,815387мс

Я думаю, это показывает, что время вычислений двух подходов более или менее одинаково (30 мс). Действительно, может потребоваться некоторое время (около 60 мс) для удаления массива во втором варианте. Хотя это странно, так как нужно просто удалить указатель

Answer 2

Если вы хотите получить тот же результат, сделайте то же самое! Очевидно, что ассигнования не будут бесплатными! Не комментируйте распределение!

Например,

Выход:

time taken:  77.726729ms 9
time taken:  78.213242ms 0

main.go

package main

import (
    "fmt"
    "math"
    "math/rand"
    "testing"
    "time"
)

// A random array of integers
func randomArray(max int, len int) []int {
    a := make([]int, len)
    for i := 0; i <= len-1; i++ {
        a[i] = rand.Intn(max)
    }
    return a
}

// Taking square root of each element in array
func sqrt_array(arr []int) []float64 {
    var len_arr = len(arr)
    a := make([]float64, len_arr)
    for i, v := range arr {
        a[i] = math.Sqrt(float64(v))
    }
    return a
}

func main1() {

    arr := randomArray(100, 10e6)
    sqrt := make([]float64, len(arr))
    start := time.Now()
    sqrt = sqrt_array(arr)
    end := time.Now()

    fmt.Println("time taken: ", end.Sub(start), sqrt[0])
}

func main2() {

    arr := randomArray(100, 10e6)
    // sqrt := make([]float64, len(arr))
    sqrt := make([]float64, len(arr))
    start := time.Now()
    _ = sqrt_array(arr)
    end := time.Now()

    fmt.Println("time taken: ", end.Sub(start), sqrt[0])
}

func main() {
    main1()
    main2()
}