RAGNAROK:
Zajimalo by me jestli funkce Measurer pujde prepsat tak ze by brala obecnou funkci.

CUCHULAIN:

package main

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

	"gonum.org/v1/gonum/stat"
)

func main() {
	rand.Seed(time.Now().Unix())
	flt := rand.Float64() * 1e20
	rand.Seed(time.Now().Unix())
	flt = flt + rand.Float64()*1e10
	rand.Seed(time.Now().Unix())
	flt = flt + rand.Float64()

	plc := rand.Intn(9)
	num := 100

	fmt.Println(flt, plc, Rounder(flt, plc))
	fmt.Println(flt, plc, Rounderp(flt, plc))
	fmt.Println()

	fn1 := Measurer(num, Rounder, flt, plc)
	fmt.Println("Rounder times:", fn1)
	fmt.Println("Rounder mean time:", stat.Mean(fn1, nil))

	fmt.Println()
	fn2 := Measurer(num, Rounderp, flt, plc)
	fmt.Println("Rounderp times:", fn2)
	fmt.Println("Rounderp mean time:", stat.Mean(fn2, nil))

}

func Measurer(num int, fn func(par float64, places int) float64, p1 float64, plc int) []float64 {
	var ott []float64
	for i := 0; i < num; i++ {
		t0 := time.Now()
		fn(p1, plc)
		t1 := float64(time.Since(t0))
		ott = append(ott, t1)
	}
	return ott
}

func Rounder(i float64, places int) float64 {
	frmt := "%." + fmt.Sprint(places) + "f"
	a, _ := strconv.ParseFloat(fmt.Sprintf(frmt, i), 64)
	return a
}

func Rounderp(i float64, places int) float64 {
	pow := math.Pow10(places)
	num := math.Round(i*pow) / pow
	return num
}

Ten tvuj zpusob je 20x rychlejsi dle horejsiho testu. :)

RAGNAROK: ok. je možný, že fmt zaokrouhluje. to jsem nezkoušel.

CUCHULAIN:
Jsem tu funkci testoval a zaokrouhluje podle pravidel.
Stim pow muze byt pro velke cisla problem preteceni.

RAGNAROK: takže třeba takhle:

package main

import (
	"fmt"
	"math"
)

func main() {
	for i := 0; i < 10; i++ {
		pow := math.Pow10(i)
		num := math.Round(9.123456789 * pow) / pow
		fmt.Println(num)
	}
}

CUCHULAIN: teda... místo 3 má být places

RAGNAROK: tohle nemáš úplně zaokrouhlování, spíš Floor.

pow := math.Pow10(3)
a := math.Round(i * pow) / pow

Neni neco lepsiho pro zaokrouhlovani na pozadovany misto? Jsem uklohnil tohle:

func Rounder(i float64, places int) (float64, error) {
	frmt := "%." + fmt.Sprint(places) + "f"
	a, err := strconv.ParseFloat(fmt.Sprintf(frmt, i), 64)
	return a, err
}

NYX: Podle toho, co znamena "na zaklade vstupnich parametru". Pokud to ma pro sudy cisla vracet int64 a pro lichy float64, tak ti generika nepomuzou, a vracet Interface je v zasade to ciste reseni.

NYX: jasně, debat ohledně vyspělosti Go je hromada, každopádně interface funguje :-)

RAGNAROK: Zadne ciste reseni. Reflexe, interface + runtime aserce nebo generovany kod jsou jen zpusoby jak ocurat absenci generik.

RAGNAROK: že bude vracet typ Interface?

Jde prosim v go vytvorit funkci ktera vraci variabilni typ? Tj. na zaklade vstupnich parametru funkce vrati treba float64, int64 nebo neco jineho.

Neni mi jasne jaktoze se v nasledujicim kodu pouzije metoda i kdyz neni explicitne volana.

package main
import (
	"fmt"
	"strconv"
	"strings"
)

type IPAddr [4]byte

func (ip IPAddr) String() string {
	s := make([]string, len(ip))
	for i, val := range ip {
		s[i] = strconv.Itoa(int(val))
	}
	return strings.Join(s, ".")
}

func main() {
	hosts := map[string]IPAddr{
		"loopback":  {127, 0, 0, 1},
		"googleDNS": {8, 8, 8, 8},
	}
	for name, ip := range hosts {
		fmt.Printf("%v: %v\n", name, ip)
	}
}