func ratingStdDev(teams []Team) (Score, []float64) { teamRatingsStdDev := make([]float64, numTeams) for i, team := range teams { if len(team.players) < 2 { teamRatingsStdDev[i] = 0 continue } playerRatings := make([]float64, len(team.players)) for j, player := range team.players { playerRatings[j] = float64(player.rating) } teamRatingsStdDev[i] = stats.StatsSampleStandardDeviation(playerRatings) } return Score(stats.StatsSampleStandardDeviation(teamRatingsStdDev)), teamRatingsStdDev }
func ratingDifference(teams []Team) (Score, []float64) { teamAverageRatings := make([]float64, numTeams) for i, team := range teams { teamAverageRatings[i] = float64(AverageRating(team)) } return Score(stats.StatsSampleStandardDeviation(teamAverageRatings)), teamAverageRatings }
func StandardDeviationInt(inList []int) float64 { floatList := make([]float64, len(inList)) for i, value := range inList { floatList[i] = float64(value) } stdDev := stats.StatsSampleStandardDeviation(floatList) return stdDev }
func main() { var header bool flag.BoolVar(&header, "t", false, "Print text header") flag.Parse() file := "" if len(flag.Args()) > 0 { file = flag.Args()[0] } m, vars, err := ltspice.Raw(file, header) if err != nil { log.Println(err) } if m == nil { log.Println("null matrix") } col := len(m) row := len(m[0]) if header { for j := 1; j < col; j++ { mean := stats.StatsMean(m[j]) sdev := stats.StatsSampleStandardDeviation(m[j]) fmt.Printf("%-20s %30g %30g %30g\n", "'"+vars[j]+"'", mean, sdev, sdev/mean) } } if header { return } for i := 0; i < row; i++ { for j := 0; j < col; j++ { fmt.Printf("%g", m[j][i]) if j < col-1 { fmt.Print(", ") } } fmt.Println("") } }
func (c *Client) Run(res chan *RunResults) { newMsgs := make(chan *Message) pubMsgs := make(chan *Message) doneGen := make(chan bool) donePub := make(chan bool) runResults := new(RunResults) started := time.Now() // start generator go c.genMessages(newMsgs, doneGen) // start publisher go c.pubMessages(newMsgs, pubMsgs, doneGen, donePub) runResults.ID = c.ID times := []float64{} for { select { case m := <-pubMsgs: if m.Error { log.Printf("CLIENT %v ERROR publishing message: %v: at %v\n", c.ID, m.Topic, m.Sent.Unix()) runResults.Failures++ } else { // log.Printf("Message published: %v: sent: %v delivered: %v flight time: %v\n", m.Topic, m.Sent, m.Delivered, m.Delivered.Sub(m.Sent)) runResults.Successes++ times = append(times, m.Delivered.Sub(m.Sent).Seconds()*1000) // in milliseconds } case <-donePub: // calculate results duration := time.Now().Sub(started) runResults.MsgTimeMin = stats.StatsMin(times) runResults.MsgTimeMax = stats.StatsMax(times) runResults.MsgTimeMean = stats.StatsMean(times) runResults.MsgTimeStd = stats.StatsSampleStandardDeviation(times) runResults.RunTime = duration.Seconds() runResults.MsgsPerSec = float64(runResults.Successes) / duration.Seconds() // report results and exit res <- runResults return } } }
func calculateTotalResults(results []*RunResults, totalTime time.Duration) *TotalResults { totals := new(TotalResults) totals.TotalRunTime = totalTime.Seconds() msgTimeMeans := make([]float64, len(results)) msgsPerSecs := make([]float64, len(results)) runTimes := make([]float64, len(results)) bws := make([]float64, len(results)) totals.MsgTimeMin = results[0].MsgTimeMin for i, res := range results { totals.Successes += res.Successes totals.Failures += res.Failures totals.TotalMsgsPerSec += res.MsgsPerSec if res.MsgTimeMin < totals.MsgTimeMin { totals.MsgTimeMin = res.MsgTimeMin } if res.MsgTimeMax > totals.MsgTimeMax { totals.MsgTimeMax = res.MsgTimeMax } msgTimeMeans[i] = res.MsgTimeMean msgsPerSecs[i] = res.MsgsPerSec runTimes[i] = res.RunTime bws[i] = res.MsgsPerSec } totals.Ratio = float64(totals.Successes) / float64(totals.Successes+totals.Failures) totals.AvgMsgsPerSec = stats.StatsMean(msgsPerSecs) totals.AvgRunTime = stats.StatsMean(runTimes) totals.MsgTimeMeanAvg = stats.StatsMean(msgTimeMeans) totals.MsgTimeMeanStd = stats.StatsSampleStandardDeviation(msgTimeMeans) return totals }
i := 1 for i < len(data) { data[i].Return = data[i].Logprice - data[i-1].Logprice i += 1 } j := 29 for j < len(data) { subset := data[j-29 : j] var returns []float64 for _, point := range subset { if !math.IsNaN(point.Return) { returns = append(returns, point.Return) } } data[j].Volatility = stats.StatsSampleStandardDeviation(returns) * 100.0 j += 1 } k := 59 for k < len(data) { subset := data[k-59 : k] var returns []float64 for _, point := range subset { if !math.IsNaN(point.Return) { returns = append(returns, point.Return) } } data[k].Volatility60 = stats.StatsSampleStandardDeviation(returns) * 100.0 k += 1 } d := StoredDataSet{
// summarizeResults Summarizes results / generates descriptive statistics so we // don't have to send tens of thousands of trials down to the client. // Receiver: None // Params: detailedData -- [][]simulationTimeStep) // Returns: []summarizedTimeStep func summarizeResults(detailedData [][]simulationTimeStep) []summarizedTimeStep { numberOfTrials := len(detailedData) numberOfPeriods := len(detailedData[0]) // Prep the slice summarizedResults := make([]summarizedTimeStep, numberOfPeriods) for period := 0; period < numberOfPeriods; period++ { outOfMoneyOccurences := 0.0 // initialize value dateInt := detailedData[0][period].dateInt // same in every trial /* Transpose the arrays so that we have a list of asset/income/expense results by period, instead of by trial. */ periodAssetResults := make([]float64, numberOfTrials) periodIncomeResults := make([]float64, numberOfTrials) periodExpensesResults := make([]float64, numberOfTrials) for trialIndex, arrayOfTrialResults := range detailedData { periodAssetResults[trialIndex] = arrayOfTrialResults[period].assets periodIncomeResults[trialIndex] = arrayOfTrialResults[period].income periodExpensesResults[trialIndex] = arrayOfTrialResults[period].expenses if arrayOfTrialResults[period].assets < 0 { outOfMoneyOccurences++ } } /* */ /* Generate descriptive statistics for each period */ outOfMoneyPercentage := outOfMoneyOccurences / float64(numberOfTrials) assetsMean := goStats.StatsMean(periodAssetResults) assetsStdDev := goStats.StatsSampleStandardDeviation(periodAssetResults) assetsCIFactor := 1.96 * assetsStdDev / math.Pow(float64(numberOfTrials), 0.5) incomeMean := goStats.StatsMean(periodIncomeResults) incomeStdDev := goStats.StatsSampleStandardDeviation(periodIncomeResults) incomeCIFactor := 1.96 * incomeStdDev / math.Pow(float64(numberOfTrials), 0.5) expensesMean := goStats.StatsMean(periodExpensesResults) expensesStdDev := goStats.StatsSampleStandardDeviation(periodExpensesResults) expensesCIFactor := 1.96 * expensesStdDev / math.Pow(float64(numberOfTrials), 0.5) /* */ // // Remove asset results where all dead? Old code -- would need fixing // allDead := false // for index, entry := range meanIncome { // if entry == 0 || meanExpenses[index] == 0 { // allDead = true // } // if allDead { // meanAssets[index] = 0 // } // } summarizedResults[period] = summarizedTimeStep{ AssetsMean: assetsMean, AssetsCILow: assetsMean - assetsCIFactor, AssetsCIHigh: assetsMean + assetsCIFactor, IncomeMean: incomeMean, IncomeCILow: incomeMean - incomeCIFactor, IncomeCIHigh: incomeMean + incomeCIFactor, ExpensesMean: expensesMean, ExpensesCILow: expensesMean - expensesCIFactor, ExpensesCIHigh: expensesMean + expensesCIFactor, OutOfMoneyPercentage: outOfMoneyPercentage, DateInt: dateInt, } } return summarizedResults }