volatilidade.go

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"math"
	"net/http"
	"strconv"
)

// Struct para armazenar o retorno de preços de 5 minutos da Binance
type BinanceData struct {
	OpenTime  int64  `json:"openTime"`
	Open      string `json:"open"`
	Close     string `json:"close"`
	High      string `json:"high"`
	Low       string `json:"low"`
	Volume    string `json:"volume"`
	CloseTime int64  `json:"closeTime"`
}

// Função para obter dados de 5 minutos da API da Binance
func getBinanceData(symbol string, interval string) ([]BinanceData, error) {
	url := fmt.Sprintf("https://api.binance.com/api/v1/klines?symbol=%s&interval=%s", symbol, interval)
	resp, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var data [][]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
		return nil, err
	}

	var result []BinanceData
	for _, d := range data {
		openTime := int64(d[0].(float64))
		closePrice := d[4].(string)
		openPrice := d[1].(string)
		highPrice := d[2].(string)
		lowPrice := d[3].(string)
		volume := d[5].(string)

		result = append(result, BinanceData{
			OpenTime:  openTime,
			Open:      openPrice,
			Close:     closePrice,
			High:      highPrice,
			Low:       lowPrice,
			Volume:    volume,
			CloseTime: int64(d[6].(float64)),
		})
	}

	return result, nil
}

// Função para calcular a volatilidade (desvio padrão dos retornos logarítmicos)
func calculateVolatility(data []BinanceData) float64 {
	var logReturns []float64
	for i := 1; i < len(data); i++ {
		closePrev := data[i-1].Close
		closeCurr := data[i].Close

		// Converta os preços de string para float64
		prev, _ := strconv.ParseFloat(closePrev, 64)
		curr, _ := strconv.ParseFloat(closeCurr, 64)

		// Calcular retorno logarítmico
		logReturn := math.Log(curr / prev)
		logReturns = append(logReturns, logReturn)
	}

	// Calcular o desvio padrão dos retornos logarítmicos
	mean := mean(logReturns)
	var sum float64
	for _, r := range logReturns {
		sum += math.Pow(r-mean, 2)
	}
	volatility := math.Sqrt(sum / float64(len(logReturns)))
	return volatility
}

// Função para calcular a média de um slice de floats
func mean(data []float64) float64 {
	var sum float64
	for _, v := range data {
		sum += v
	}
	return sum / float64(len(data))
}

func main() {
	// Defina o símbolo e intervalo desejados
	symbol := "BTCUSDT"
	interval := "5m"

	// Obtenha os dados de 5 minutos da Binance
	data, err := getBinanceData(symbol, interval)
	if err != nil {
		log.Fatalf("Erro ao obter dados da Binance: %v", err)
	}

	// Calcule a volatilidade
	volatility := calculateVolatility(data)
	fmt.Printf("A volatilidade intradiária (5min) do BTC/USD é: %f\n", volatility)
}