finalytics

package
v0.1.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 23, 2025 License: MIT Imports: 14 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func StringSliceToJSON 

func StringSliceToJSON(slice []string) (string, error)

StringSliceToJSON converts a []string to a JSON string array.

Types

type HTML 

type HTML struct {
	Content string
}

HTML stores the HTML string for a chart, table or report.

func (*HTML) Show 

func (c *HTML) Show() error

Show writes the HTML to a temporary file and opens it in the default browser.

type Portfolio 

type Portfolio struct {
	// contains filtered or unexported fields
}

Portfolio represents a portfolio of assets with methods for retrieving optimization results and analytics. It encapsulates a handle to the underlying C library for interacting with portfolio data.

func (*Portfolio) AssetReturnsChart 

func (p *Portfolio) AssetReturnsChart(height, width uint) (HTML, error)

AssetReturnsChart retrieves the asset returns chart for the portfolio as an HTML object.

Parameters:

  • height: The height of the chart (0 for default).
  • width: The width of the chart (0 for default).

Returns:

  • HTML: An HTML object containing the asset returns chart.
  • error: An error if the chart retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	portfolio, err := finalytics.NewPortfolioBuilder().
		TickerSymbols([]string{"AAPL", "MSFT", "NVDA", "BTC-USD"}).
		BenchmarkSymbol("^GSPC").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		ObjectiveFunction("max_sharpe").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Portfolio: %v\n", err)
		return
	}
	defer portfolio.Free()

	assetChart, err := portfolio.AssetReturnsChart(0, 0)
	if err != nil {
		fmt.Printf("Failed to get asset returns chart: %v\n", err)
		return
	}
	assetChart.Show()
}

func (*Portfolio) Free 

func (p *Portfolio) Free()

Free releases the resources associated with the Portfolio. It should be called when the Portfolio is no longer needed to prevent memory leaks.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	portfolio, err := finalytics.NewPortfolioBuilder().
		TickerSymbols([]string{"AAPL", "MSFT", "NVDA", "BTC-USD"}).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Portfolio: %v\n", err)
		return
	}
	portfolio.Free()
	fmt.Println("Portfolio resources freed successfully")
}

func (*Portfolio) OptimizationChart 

func (p *Portfolio) OptimizationChart(height, width uint) (HTML, error)

OptimizationChart retrieves the portfolio optimization chart as an HTML object.

Parameters:

  • height: The height of the chart (0 for default).
  • width: The width of the chart (0 for default).

Returns:

  • HTML: An HTML object containing the optimization chart.
  • error: An error if the chart retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	portfolio, err := finalytics.NewPortfolioBuilder().
		TickerSymbols([]string{"AAPL", "MSFT", "NVDA", "BTC-USD"}).
		BenchmarkSymbol("^GSPC").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		ObjectiveFunction("max_sharpe").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Portfolio: %v\n", err)
		return
	}
	defer portfolio.Free()

	optChart, err := portfolio.OptimizationChart(0, 0)
	if err != nil {
		fmt.Printf("Failed to get optimization chart: %v\n", err)
		return
	}
	optChart.Show()
}

func (*Portfolio) OptimizationResults 

func (p *Portfolio) OptimizationResults() (map[string]any, error)

OptimizationResults retrieves portfolio optimization results.

Returns:

  • map[string]any: A map containing the optimization results (e.g., weights, expected return, volatility).
  • error: An error if the optimization results retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	portfolio, err := finalytics.NewPortfolioBuilder().
		TickerSymbols([]string{"AAPL", "MSFT", "NVDA", "BTC-USD"}).
		BenchmarkSymbol("^GSPC").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		ObjectiveFunction("max_sharpe").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Portfolio: %v\n", err)
		return
	}
	defer portfolio.Free()

	results, err := portfolio.OptimizationResults()
	if err != nil {
		fmt.Printf("Failed to get optimization results: %v\n", err)
		return
	}
	fmt.Printf("Optimization Results: %v\n", results)
}

func (*Portfolio) PerformanceChart 

func (p *Portfolio) PerformanceChart(height, width uint) (HTML, error)

PerformanceChart retrieves the portfolio performance chart as an HTML object.

Parameters:

  • height: The height of the chart (0 for default).
  • width: The width of the chart (0 for default).

Returns:

  • HTML: An HTML object containing the performance chart.
  • error: An error if the chart retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	portfolio, err := finalytics.NewPortfolioBuilder().
		TickerSymbols([]string{"AAPL", "MSFT", "NVDA", "BTC-USD"}).
		BenchmarkSymbol("^GSPC").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		ObjectiveFunction("max_sharpe").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Portfolio: %v\n", err)
		return
	}
	defer portfolio.Free()

	perfChart, err := portfolio.PerformanceChart(0, 0)
	if err != nil {
		fmt.Printf("Failed to get performance chart: %v\n", err)
		return
	}
	perfChart.Show()
}

func (*Portfolio) PerformanceStats added in v0.1.1 

func (t *Portfolio) PerformanceStats() (dataframe.DataFrame, error)

PerformanceStats retrieves performance statistics for the portfolio.

Returns:

  • dataframe.DataFrame: A DataFrame containing aggregated performance statistics for the portfolio (e.g., returns, volatility, Sharpe ratio).
  • error: An error if the performance statistics retrieval fails.

Example: 

  package main

  import (
  	"fmt"
  	"github.com/Nnamdi-sys/finalytics/go/finalytics"
  	"github.com/go-gota/gota/dataframe"
  )

  func main() {
		portfolio, err := finalytics.NewPortfolioBuilder().
			TickerSymbols([]string{"AAPL", "MSFT", "NVDA", "BTC-USD"}).
			BenchmarkSymbol("^GSPC").
			StartDate("2023-01-01").
			EndDate("2023-12-31").
			Interval("1d").
			ConfidenceLevel(0.95).
			RiskFreeRate(0.02).
			ObjectiveFunction("max_sharpe").
			Build()
		if err != nil {
			fmt.Printf("Failed to create Portfolio: %v\n", err)
			return
		}
		defer portfolio.Free()

  	perfStats, err := portfolio.PerformanceStats()
  	if err != nil {
  		fmt.Printf("Failed to get performance stats: %v\n", err)
  		return
  	}
  	fmt.Printf("Performance Stats:\n%v\n", perfStats)
  }

func (*Portfolio) Report 

func (p *Portfolio) Report(reportType string) (HTML, error)

Report retrieves a comprehensive report for the portfolio as an HTML object.

Parameters:

  • reportType: The type of report to display (e.g., "performance").

Returns:

  • HTML: An HTML object containing the report.
  • error: An error if the report retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	portfolio, err := finalytics.NewPortfolioBuilder().
		TickerSymbols([]string{"AAPL", "MSFT", "NVDA", "BTC-USD"}).
		BenchmarkSymbol("^GSPC").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		ObjectiveFunction("max_sharpe").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Portfolio: %v\n", err)
		return
	}
	defer portfolio.Free()

	report, err := portfolio.Report("performance")
	if err != nil {
		fmt.Printf("Failed to get report: %v\n", err)
		return
	}
	report.Show()
}

func (*Portfolio) ReturnsMatrix 

func (p *Portfolio) ReturnsMatrix(height, width uint) (HTML, error)

ReturnsMatrix retrieves the returns correlation matrix for the portfolio as an HTML object.

Parameters:

  • height: The height of the chart (0 for default).
  • width: The width of the chart (0 for default).

Returns:

  • HTML: An HTML object containing the returns correlation matrix.
  • error: An error if the matrix retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	portfolio, err := finalytics.NewPortfolioBuilder().
		TickerSymbols([]string{"AAPL", "MSFT", "NVDA", "BTC-USD"}).
		BenchmarkSymbol("^GSPC").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		ObjectiveFunction("max_sharpe").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Portfolio: %v\n", err)
		return
	}
	defer portfolio.Free()

	retMatrix, err := portfolio.ReturnsMatrix(0, 0)
	if err != nil {
		fmt.Printf("Failed to get returns matrix: %v\n", err)
		return
	}
	retMatrix.Show()
}

type PortfolioBuilder 

type PortfolioBuilder struct {
	// contains filtered or unexported fields
}

PortfolioBuilder is used to construct a Portfolio instance using the builder pattern. It allows for fluent configuration of the Portfolio's parameters before creation.

func NewPortfolioBuilder 

func NewPortfolioBuilder() *PortfolioBuilder

NewPortfolioBuilder initializes a new PortfolioBuilder with default values. Defaults:

  • tickerSymbols: nil
  • benchmarkSymbol: ""
  • startDate: ""
  • endDate: ""
  • interval: "1d"
  • confidenceLevel: 0.95
  • riskFreeRate: 0.02
  • objectiveFunction: "max_sharpe"
  • assetConstraints: "{}"
  • categoricalConstraints: "{}"
  • weights: "{}"
  • tickersData: nil
  • benchmarkData: nil

Returns:

  • *PortfolioBuilder: A pointer to the initialized PortfolioBuilder.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	builder := finalytics.NewPortfolioBuilder()
	fmt.Println("PortfolioBuilder initialized")
}

func (*PortfolioBuilder) AssetConstraints 

func (b *PortfolioBuilder) AssetConstraints(assetConstraints string) *PortfolioBuilder

AssetConstraints sets the asset-level constraints for optimization.

Parameters:

  • assetConstraints: JSON string defining asset-level constraints (e.g., `[[0,1],[0,1]]` for min/max weights).

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().AssetConstraints(`[[0,1],[0,1]]`)

func (*PortfolioBuilder) BenchmarkData 

func (b *PortfolioBuilder) BenchmarkData(benchmarkData *dataframe.DataFrame) *PortfolioBuilder

BenchmarkData sets custom benchmark data for the Portfolio.

Parameters:

  • benchmarkData: A DataFrame containing custom benchmark data (pass nil if not using custom data).

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().BenchmarkData(nil)

func (*PortfolioBuilder) BenchmarkSymbol 

func (b *PortfolioBuilder) BenchmarkSymbol(benchmarkSymbol string) *PortfolioBuilder

BenchmarkSymbol sets the benchmark symbol for the Portfolio.

Parameters:

  • benchmarkSymbol: The ticker symbol of the benchmark (e.g., "^GSPC").

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().BenchmarkSymbol("^GSPC")

func (*PortfolioBuilder) Build 

func (b *PortfolioBuilder) Build() (*Portfolio, error)

Build constructs the Portfolio instance with the configured parameters. The tickerSymbols parameter is required; other parameters are optional and use defaults if not set.

Returns:

  • *Portfolio: A pointer to the initialized Portfolio object.
  • error: An error if the Portfolio creation fails or tickerSymbols is missing/empty.

Example: 

package main

import (
	"encoding/json"
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	// Sample asset constraints: min/max weights for each asset
	assetConstraints, err := json.Marshal([][2]float64{{0.1, 0.5}, {0.1, 0.5}, {0.1, 0.5}, {0.1, 0.5}})
	if err != nil {
		fmt.Printf("Failed to marshal assetConstraints: %v\n", err)
		return
	}

	// Sample categorical constraints: limit EQUITY to 80% and CRYPTO to 20%
	categoricalConstraints, err := json.Marshal([]map[string]interface{}{
		{
			"name": "AssetClass",
			"category_per_symbol": []string{"EQUITY", "EQUITY", "EQUITY", "EQUITY", "CRYPTO"},
			"weight_per_category": [][]interface{}{
				{"EQUITY", 0.0, 0.8},
				{"CRYPTO", 0.0, 0.2},
			},
		},
	})
	if err != nil {
		fmt.Printf("Error marshaling categoricalConstraints: %v\n", err)
		return
	}

	portfolio, err := finalytics.NewPortfolioBuilder().
		TickerSymbols([]string{"AAPL", "MSFT", "NVDA", "BTC-USD"}).
		BenchmarkSymbol("^GSPC").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		ObjectiveFunction("max_sharpe").
		AssetConstraints(string(assetConstraints)).
		CategoricalConstraints(string(categoricalConstraints)).
		weights("{}").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Portfolio: %v\n", err)
		return
	}
	defer portfolio.Free()
	fmt.Println("Portfolio created successfully for AAPL, MSFT, NVDA, and BTC-USD")
}

func (*PortfolioBuilder) CategoricalConstraints 

func (b *PortfolioBuilder) CategoricalConstraints(categoricalConstraints string) *PortfolioBuilder

CategoricalConstraints sets the categorical constraints for optimization.

Parameters:

  • categoricalConstraints: JSON string defining categorical constraints (e.g., constraints on asset classes).

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().CategoricalConstraints(`[{"Name":"AssetClass","Categories":["EQUITY","EQUITY"],"Constraints":[["EQUITY",0.0,0.8]]}]`)

func (*PortfolioBuilder) ConfidenceLevel 

func (b *PortfolioBuilder) ConfidenceLevel(confidenceLevel float64) *PortfolioBuilder

ConfidenceLevel sets the confidence level for VaR and ES calculations.

Parameters:

  • confidenceLevel: The confidence level (e.g., 0.95 for 95% confidence).

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().ConfidenceLevel(0.99)

func (*PortfolioBuilder) EndDate 

func (b *PortfolioBuilder) EndDate(endDate string) *PortfolioBuilder

EndDate sets the end date for the Portfolio's data period.

Parameters:

  • endDate: The end date in the format YYYY-MM-DD.

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().EndDate("2023-12-31")

func (*PortfolioBuilder) Interval 

func (b *PortfolioBuilder) Interval(interval string) *PortfolioBuilder

Interval sets the data interval for the Portfolio.

Parameters:

  • interval: The data interval (e.g., "2m", "5m", "15m", "30m", "1h", "1d", "1wk", "1mo", "3mo").

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().Interval("1d")

func (*PortfolioBuilder) ObjectiveFunction 

func (b *PortfolioBuilder) ObjectiveFunction(objectiveFunction string) *PortfolioBuilder

ObjectiveFunction sets the objective function for optimization.

Parameters:

  • objectiveFunction: The objective function (e.g., "max_sharpe", "max_sortino", "max_return", "min_vol", "min_var", "min_cvar", "min_drawdown").

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().ObjectiveFunction("max_sharpe")

func (*PortfolioBuilder) RiskFreeRate 

func (b *PortfolioBuilder) RiskFreeRate(riskFreeRate float64) *PortfolioBuilder

RiskFreeRate sets the risk-free rate for calculations.

Parameters:

  • riskFreeRate: The risk-free rate (e.g., 0.02 for 2%).

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().RiskFreeRate(0.03)

func (*PortfolioBuilder) StartDate 

func (b *PortfolioBuilder) StartDate(startDate string) *PortfolioBuilder

StartDate sets the start date for the Portfolio's data period.

Parameters:

  • startDate: The start date in the format YYYY-MM-DD.

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().StartDate("2023-01-01")

func (*PortfolioBuilder) TickerSymbols 

func (b *PortfolioBuilder) TickerSymbols(tickerSymbols []string) *PortfolioBuilder

TickerSymbols sets the ticker symbols for the Portfolio.

Parameters:

  • tickerSymbols: A string slice of ticker symbols (e.g., []string{"AAPL", "MSFT"}).

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().TickerSymbols([]string{"AAPL", "MSFT"})

func (*PortfolioBuilder) TickersData 

func (b *PortfolioBuilder) TickersData(tickersData []dataframe.DataFrame) *PortfolioBuilder

TickersData sets custom ticker data for the Portfolio.

Parameters:

  • tickersData: A slice of DataFrames containing custom ticker data for each symbol (pass nil or empty slice if not using custom data).

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().TickersData(nil)

func (*PortfolioBuilder) Weights 

func (b *PortfolioBuilder) Weights(weights string) *PortfolioBuilder

weights sets the portfolio-level constraints for optimization.

Parameters:

  • weights: JSON string defining portfolio-level constraints (e.g., "{}").

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewPortfolioBuilder().weights("{}")

type Screener 

type Screener struct {
	// contains filtered or unexported fields
}

Screener represents a stock screener for filtering financial instruments based on specified criteria. It encapsulates a handle to the underlying C library for interacting with screener data.

func NewScreener 

func NewScreener(quoteType string, filters []string, sortField string, sortDescending bool, offset, size uint) (*Screener, error)

NewScreener creates a new Screener instance with the given parameters.

Parameters:

  • quoteType: The type of financial instrument to screen (e.g., "EQUITY", "MUTUALFUND", "ETF", "INDEX", "FUTURE", "CRYPTO").
  • filters: A string slice, where each element is a JSON object representing a filter criterion. Each filter should have the format: { "operator": "<op>", "operands": ["<metric>", <value>[, <value2>]] } Supported operators are "eq" (equal), "gte" (greater than or equal), "lte" (less than or equal), "gt" (greater than), "lt" (less than), or "btwn" (between, requiring two values). The `<metric>` must be a valid screener metric for the quote type (e.g., "intradaymarketcap" for EQUITY). A full list of metrics is available at: https://github.com/Nnamdi-sys/finalytics/tree/main/rust/src/data/yahoo/screeners/screeners.json.
  • sortField: The metric to sort by (e.g., "intradaymarketcap" for EQUITY). If empty, no sorting is applied.
  • sortDescending: Whether to sort in descending order (true) or ascending order (false).
  • offset: The starting index of results to return (e.g., 0 to start from the beginning).
  • size: The maximum number of results to return (e.g., 10 for the top 10 results).

Returns:

  • *Screener: A pointer to the initialized Screener object.
  • error: An error if the Screener creation fails.

Example: 

  package main

  import (
  	"fmt"
  	"github.com/Nnamdi-sys/finalytics/go/finalytics"
  )

  func main() {
  	// Sample filters: select equities on the NMS exchange with market cap >= 10B
  	filters := []string{
		    `{"operator":"eq","operands":["exchange","NMS"]}`,
		    `{"operator":"gte","operands":["intradaymarketcap",10000000000]}`
		}

  	screener, err := finalytics.NewScreener("EQUITY", filters, "intradaymarketcap", true, 0, 10)
  	if err != nil {
  		fmt.Printf("Failed to create Screener: %v\n", err)
  		return
  	}
  	defer screener.Free()
  	fmt.Println("Screener created successfully for EQUITY on NMS with market cap >= 10B")
  }

func (*Screener) Free 

func (s *Screener) Free()

Free releases the resources associated with the Screener. It should be called when the Screener is no longer needed to prevent memory leaks.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	screener, err := finalytics.NewScreener("EQUITY", `[{"operator": "eq", "operands": ["exchange", "NMS"]}]`, "intradaymarketcap", true, 0, 10)
	if err != nil {
		fmt.Printf("Failed to create Screener: %v\n", err)
		return
	}
	screener.Free()
	fmt.Println("Screener resources freed successfully")
}

func (*Screener) Metrics 

func (s *Screener) Metrics() (dataframe.DataFrame, error)

Metrics retrieves detailed metrics for the screened instruments.

Returns:

  • dataframe.DataFrame: A DataFrame containing detailed metrics for the screened instruments.
  • error: An error if the metrics retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	screener, err := finalytics.NewScreener("EQUITY", `[{"operator": "eq", "operands": ["exchange", "NMS"]}]`, "intradaymarketcap", true, 0, 10)
	if err != nil {
		fmt.Printf("Failed to create Screener: %v\n", err)
		return
	}
	defer screener.Free()

	metrics, err := screener.Metrics()
	if err != nil {
		fmt.Printf("Failed to get metrics: %v\n", err)
		return
	}
	fmt.Printf("Metrics:\n%v\n", metrics)
}

func (*Screener) Overview 

func (s *Screener) Overview() (dataframe.DataFrame, error)

Overview retrieves overview data for the screened instruments.

Returns:

  • dataframe.DataFrame: A DataFrame containing overview data for the screened instruments.
  • error: An error if the overview retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	screener, err := finalytics.NewScreener("EQUITY", `[{"operator": "eq", "operands": ["exchange", "NMS"]}]`, "intradaymarketcap", true, 0, 10)
	if err != nil {
		fmt.Printf("Failed to create Screener: %v\n", err)
		return
	}
	defer screener.Free()

	overview, err := screener.Overview()
	if err != nil {
		fmt.Printf("Failed to get overview: %v\n", err)
		return
	}
	fmt.Printf("Overview:\n%v\n", overview)
}

func (*Screener) Symbols 

func (s *Screener) Symbols() ([]string, error)

Symbols retrieves the list of ticker symbols matching the screener criteria.

Returns:

  • []string: A slice of ticker symbols (e.g., ["AAPL", "MSFT", "GOOGL"]).
  • error: An error if the symbols retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	screener, err := finalytics.NewScreener("EQUITY", `[{"operator": "eq", "operands": ["exchange", "NMS"]}]`, "intradaymarketcap", true, 0, 10)
	if err != nil {
		fmt.Printf("Failed to create Screener: %v\n", err)
		return
	}
	defer screener.Free()

	symbols, err := screener.Symbols()
	if err != nil {
		fmt.Printf("Failed to get symbols: %v\n", err)
		return
	}
	fmt.Printf("Symbols: %v\n", symbols)
}

type Ticker 

type Ticker struct {
	// contains filtered or unexported fields
}

Ticker represents a financial ticker with methods for retrieving financial data and analytics. It encapsulates a handle to the underlying C library for interacting with financial data.

func (*Ticker) CandlestickChart 

func (t *Ticker) CandlestickChart(height, width uint) (HTML, error)

CandlestickChart retrieves the candlestick chart for the ticker as an HTML object.

Parameters:

  • height: The height of the chart (0 for default).
  • width: The width of the chart (0 for default).

Returns:

  • HTML: An HTML object containing the candlestick chart.
  • error: An error if the chart retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	candleChart, err := ticker.CandlestickChart(0, 0)
	if err != nil {
		fmt.Printf("Failed to get candlestick chart: %v\n", err)
		return
	}
	candleChart.Show()
}

func (*Ticker) Free 

func (t *Ticker) Free()

Free releases the resources associated with the Ticker. It should be called when the Ticker is no longer needed to prevent memory leaks.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		BenchmarkSymbol("^GSPC").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	ticker.Free()
	fmt.Println("Ticker resources freed successfully")
}

func (*Ticker) GetBalanceSheet 

func (t *Ticker) GetBalanceSheet(frequency string, formatted bool) (dataframe.DataFrame, error)

GetBalanceSheet retrieves the balance sheet for the ticker.

Parameters:

  • frequency: The frequency of the statement ("annual" or "quarterly").
  • formatted: Whether to return the statement in a formatted manner.

Returns:

  • dataframe.DataFrame: A DataFrame containing the balance sheet data.
  • error: An error if the balance sheet retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	balance, err := ticker.GetBalanceSheet("quarterly", true)
	if err != nil {
		fmt.Printf("Failed to get balance sheet: %v\n", err)
		return
	}
	fmt.Printf("Balance Sheet:\n%v\n", balance)
}

func (*Ticker) GetCashflowStatement 

func (t *Ticker) GetCashflowStatement(frequency string, formatted bool) (dataframe.DataFrame, error)

GetCashflowStatement retrieves the cash flow statement for the ticker.

Parameters:

  • frequency: The frequency of the statement ("annual" or "quarterly").
  • formatted: Whether to return the statement in a formatted manner.

Returns:

  • dataframe.DataFrame: A DataFrame containing the cash flow statement data.
  • error: An error if the cash flow statement retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	cashflow, err := ticker.GetCashflowStatement("quarterly", true)
	if err != nil {
		fmt.Printf("Failed to get cash flow statement: %v\n", err)
		return
	}
	fmt.Printf("Cash Flow Statement:\n%v\n", cashflow)
}

func (*Ticker) GetFinancialRatios 

func (t *Ticker) GetFinancialRatios(frequency string) (dataframe.DataFrame, error)

GetFinancialRatios retrieves financial ratios for the ticker.

Parameters:

  • frequency: The frequency of the ratios ("annual" or "quarterly").

Returns:

  • dataframe.DataFrame: A DataFrame containing financial ratios.
  • error: An error if the financial ratios retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	ratios, err := ticker.GetFinancialRatios("quarterly")
	if err != nil {
		fmt.Printf("Failed to get financial ratios: %v\n", err)
		return
	}
	fmt.Printf("Financial Ratios:\n%v\n", ratios)
}

func (*Ticker) GetIncomeStatement 

func (t *Ticker) GetIncomeStatement(frequency string, formatted bool) (dataframe.DataFrame, error)

GetIncomeStatement retrieves the income statement for the ticker.

Parameters:

  • frequency: The frequency of the statement ("annual" or "quarterly").
  • formatted: Whether to return the statement in a formatted manner.

Returns:

  • dataframe.DataFrame: A DataFrame containing the income statement data.
  • error: An error if the income statement retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	income, err := ticker.GetIncomeStatement("quarterly", true)
	if err != nil {
		fmt.Printf("Failed to get income statement: %v\n", err)
		return
	}
	fmt.Printf("Income Statement:\n%v\n", income)
}

func (*Ticker) GetNews 

func (t *Ticker) GetNews() (dataframe.DataFrame, error)

GetNews retrieves the latest news headlines for the ticker.

Returns:

  • dataframe.DataFrame: A DataFrame containing news data.
  • error: An error if the news retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	news, err := ticker.GetNews()
	if err != nil {
		fmt.Printf("Failed to get news: %v\n", err)
		return
	}
	fmt.Printf("News:\n%v\n", news)
}

func (*Ticker) GetOptionsChain 

func (t *Ticker) GetOptionsChain() (dataframe.DataFrame, error)

GetOptionsChain retrieves the options chain for the ticker.

Returns:

  • dataframe.DataFrame: A DataFrame containing the options chain data.
  • error: An error if the options chain retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	options, err := ticker.GetOptionsChain()
	if err != nil {
		fmt.Printf("Failed to get options chain: %v\n", err)
		return
	}
	fmt.Printf("Options Chain:\n%v\n", options)
}

func (*Ticker) GetPriceHistory 

func (t *Ticker) GetPriceHistory() (dataframe.DataFrame, error)

GetPriceHistory retrieves the OHLCV (Open, High, Low, Close, Volume) price history for the ticker.

Returns:

  • dataframe.DataFrame: A DataFrame containing the price history data.
  • error: An error if the price history retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	history, err := ticker.GetPriceHistory()
	if err != nil {
		fmt.Printf("Failed to get price history: %v\n", err)
		return
	}
	fmt.Printf("Price History:\n%v\n", history)
}

func (*Ticker) GetQuote 

func (t *Ticker) GetQuote() (map[string]any, error)

GetQuote retrieves the current quote for the ticker.

Returns:

  • map[string]any: A map containing the current quote data (e.g., symbol, price, volume).
  • error: An error if the quote retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	quote, err := ticker.GetQuote()
	if err != nil {
		fmt.Printf("Failed to get quote: %v\n", err)
		return
	}
	fmt.Printf("Quote: %v\n", quote)
}

func (*Ticker) GetSummaryStats 

func (t *Ticker) GetSummaryStats() (dataframe.DataFrame, error)

GetSummaryStats retrieves summary technical and fundamental statistics for the ticker.

Returns:

  • dataframe.DataFrame: A DataFrame containing summary statistics.
  • error: An error if the statistics retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	summary, err := ticker.GetSummaryStats()
	if err != nil {
		fmt.Printf("Failed to get summary stats: %v\n", err)
		return
	}
	fmt.Printf("Summary Stats:\n%v\n", summary)
}

func (*Ticker) NewsSentimentChart 

func (t *Ticker) NewsSentimentChart(height, width uint) (HTML, error)

NewsSentimentChart retrieves the news sentiment chart for the ticker as an HTML object.

Parameters:

  • height: The height of the chart (0 for default).
  • width: The width of the chart (0 for default).

Returns:

  • HTML: An HTML object containing the news sentiment chart.
  • error: An error if the chart retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	newsChart, err := ticker.NewsSentimentChart(0, 0)
	if err != nil {
		fmt.Printf("Failed to get news sentiment chart: %v\n", err)
		return
	}
	newsChart.Show()
}

func (*Ticker) OptionsChart 

func (t *Ticker) OptionsChart(chartType string, height, width uint) (HTML, error)

OptionsChart retrieves the options chart (e.g., volatility surface, smile, or term structure) for the ticker as an HTML object.

Parameters:

  • chartType: The type of chart to display ("surface", "smile", or "term_structure").
  • height: The height of the chart (0 for default).
  • width: The width of the chart (0 for default).

Returns:

  • HTML: An HTML object containing the options chart.
  • error: An error if the chart retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	optChart, err := ticker.OptionsChart("surface", 0, 0)
	if err != nil {
		fmt.Printf("Failed to get options chart: %v\n", err)
		return
	}
	optChart.Show()
}

func (*Ticker) PerformanceChart 

func (t *Ticker) PerformanceChart(height, width uint) (HTML, error)

PerformanceChart retrieves the performance chart for the ticker as an HTML object.

Parameters:

  • height: The height of the chart (0 for default).
  • width: The width of the chart (0 for default).

Returns:

  • HTML: An HTML object containing the performance chart.
  • error: An error if the chart retrieval fails.

Example: 

  package main

  import (
  	"fmt"
  	"github.com/Nnamdi-sys/finalytics/go/finalytics"
  )

  func main() {
  	ticker, err := finalytics.NewTickerBuilder().
  		Symbol("AAPL").
  		StartDate("2023-01-01").
  		EndDate("2023-12-31").
  		Interval("1d").
  		BenchmarkSymbol("^GSPC").
			ConfidenceLevel(0.95).
			RiskFreeRate(0.02).
  		Build()
  	if err != nil {
  		fmt.Printf("Failed to create Ticker: %v\n", err)
  		return
  	}
  	defer ticker.Free()

  	perfChart, err := ticker.PerformanceChart(0, 0)
  	if err != nil {
  		fmt.Printf("Failed to get performance chart: %v\n", err)
  		return
  	}
  	perfChart.Show()
  }

func (*Ticker) PerformanceStats 

func (t *Ticker) PerformanceStats() (map[string]any, error)

PerformanceStats retrieves performance statistics for the ticker.

Returns:

  • map[string]any: A map containing performance statistics (e.g., returns, volatility, Sharpe ratio).
  • error: An error if the performance statistics retrieval fails.

Example: 

  package main

  import (
  	"fmt"
  	"github.com/Nnamdi-sys/finalytics/go/finalytics"
  )

  func main() {
  	ticker, err := finalytics.NewTickerBuilder().
  		Symbol("AAPL").
  		StartDate("2023-01-01").
  		EndDate("2023-12-31").
  		Interval("1d").
  		BenchmarkSymbol("^GSPC").
			ConfidenceLevel(0.95).
			RiskFreeRate(0.02).
  		Build()
  	if err != nil {
  		fmt.Printf("Failed to create Ticker: %v\n", err)
  		return
  	}
  	defer ticker.Free()

  	perfStats, err := ticker.PerformanceStats()
  	if err != nil {
  		fmt.Printf("Failed to get performance stats: %v\n", err)
  		return
  	}
  	fmt.Printf("Performance Stats: %v\n", perfStats)
  }

func (*Ticker) Report 

func (t *Ticker) Report(reportType string) (HTML, error)

Report retrieves a comprehensive analytics report for the ticker as an HTML object.

Parameters:

  • reportType: The type of report to display (e.g., "performance", "financials", "options", "news").

Returns:

  • HTML: An HTML object containing the report.
  • error: An error if the report retrieval fails.

Example: 

  package main

  import (
  	"fmt"
  	"github.com/Nnamdi-sys/finalytics/go/finalytics"
  )

  func main() {
  	ticker, err := finalytics.NewTickerBuilder().
  		Symbol("AAPL").
  		StartDate("2023-01-01").
  		EndDate("2023-12-31").
  		Interval("1d").
  		BenchmarkSymbol("^GSPC").
			ConfidenceLevel(0.95).
			RiskFreeRate(0.02).
  		Build()
  	if err != nil {
  		fmt.Printf("Failed to create Ticker: %v\n", err)
  		return
  	}
  	defer ticker.Free()

  	report, err := ticker.Report("performance")
  	if err != nil {
  		fmt.Printf("Failed to get report: %v\n", err)
  		return
  	}
  	report.Show()
  }

func (*Ticker) VolatilitySurface 

func (t *Ticker) VolatilitySurface() (dataframe.DataFrame, error)

VolatilitySurface retrieves the implied volatility surface for the ticker's options chain.

Returns:

  • dataframe.DataFrame: A DataFrame containing the volatility surface data.
  • error: An error if the volatility surface retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()

	volSurface, err := ticker.VolatilitySurface()
	if err != nil {
		fmt.Printf("Failed to get volatility surface: %v\n", err)
		return
	}
	fmt.Printf("Volatility Surface:\n%v\n", volSurface)
}

type TickerBuilder 

type TickerBuilder struct {
	// contains filtered or unexported fields
}

TickerBuilder is used to construct a Ticker instance using the builder pattern. It allows for fluent configuration of the Ticker's parameters before creation.

func NewTickerBuilder 

func NewTickerBuilder() *TickerBuilder

NewTickerBuilder initializes a new TickerBuilder with default values. Defaults:

  • confidenceLevel: 0.95
  • riskFreeRate: 0.02
  • interval: "1d"
  • startDate: ""
  • endDate: ""
  • benchmarkSymbol: ""
  • tickerData: nil
  • benchmarkData: nil

Returns:

  • *TickerBuilder: A pointer to the initialized TickerBuilder.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	builder := finalytics.NewTickerBuilder()
	fmt.Println("TickerBuilder initialized")
}

func (*TickerBuilder) BenchmarkData 

func (b *TickerBuilder) BenchmarkData(benchmarkData *dataframe.DataFrame) *TickerBuilder

BenchmarkData sets custom benchmark data for the Ticker.

Parameters:

  • benchmarkData: A DataFrame containing custom benchmark data (pass nil if not using custom data).

Returns:

  • *TickerBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickerBuilder().BenchmarkData(nil)

func (*TickerBuilder) BenchmarkSymbol 

func (b *TickerBuilder) BenchmarkSymbol(benchmarkSymbol string) *TickerBuilder

BenchmarkSymbol sets the benchmark symbol for the Ticker.

Parameters:

  • benchmarkSymbol: The ticker symbol of the benchmark (e.g., "^GSPC").

Returns:

  • *TickerBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickerBuilder().BenchmarkSymbol("^GSPC")

func (*TickerBuilder) Build 

func (b *TickerBuilder) Build() (*Ticker, error)

Build constructs the Ticker instance with the configured parameters. The symbol parameter is required; other parameters are optional and use defaults if not set.

Returns:

  • *Ticker: A pointer to the initialized Ticker object.
  • error: An error if the Ticker creation fails or the symbol is missing.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	ticker, err := finalytics.NewTickerBuilder().
		Symbol("AAPL").
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		BenchmarkSymbol("^GSPC").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Ticker: %v\n", err)
		return
	}
	defer ticker.Free()
	fmt.Println("Ticker created successfully for AAPL")
}

func (*TickerBuilder) ConfidenceLevel 

func (b *TickerBuilder) ConfidenceLevel(confidenceLevel float64) *TickerBuilder

ConfidenceLevel sets the confidence level for VaR and ES calculations.

Parameters:

  • confidenceLevel: The confidence level (e.g., 0.95 for 95% confidence).

Returns:

  • *TickerBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickerBuilder().ConfidenceLevel(0.99)

func (*TickerBuilder) EndDate 

func (b *TickerBuilder) EndDate(endDate string) *TickerBuilder

EndDate sets the end date for the Ticker's data period.

Parameters:

  • endDate: The end date in the format YYYY-MM-DD.

Returns:

  • *TickerBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickerBuilder().EndDate("2023-12-31")

func (*TickerBuilder) Interval 

func (b *TickerBuilder) Interval(interval string) *TickerBuilder

Interval sets the data interval for the Ticker.

Parameters:

  • interval: The data interval (e.g., "2m", "5m", "15m", "30m", "1h", "1d", "1wk", "1mo", "3mo").

Returns:

  • *TickerBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickerBuilder().Interval("1d")

func (*TickerBuilder) RiskFreeRate 

func (b *TickerBuilder) RiskFreeRate(riskFreeRate float64) *TickerBuilder

RiskFreeRate sets the risk-free rate for calculations.

Parameters:

  • riskFreeRate: The risk-free rate (e.g., 0.02 for 2%).

Returns:

  • *TickerBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickerBuilder().RiskFreeRate(0.03)

func (*TickerBuilder) StartDate 

func (b *TickerBuilder) StartDate(startDate string) *TickerBuilder

StartDate sets the start date for the Ticker's data period.

Parameters:

  • startDate: The start date in the format YYYY-MM-DD.

Returns:

  • *TickerBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickerBuilder().StartDate("2023-01-01")

func (*TickerBuilder) Symbol 

func (b *TickerBuilder) Symbol(symbol string) *TickerBuilder

Symbol sets the ticker symbol for the Ticker.

Parameters:

  • symbol: The ticker symbol of the asset (e.g., "AAPL").

Returns:

  • *TickerBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickerBuilder().Symbol("AAPL")

func (*TickerBuilder) TickerData 

func (b *TickerBuilder) TickerData(tickerData *dataframe.DataFrame) *TickerBuilder

TickerData sets custom ticker data for the Ticker.

Parameters:

  • tickerData: A DataFrame containing custom ticker data (pass nil if not using custom data).

Returns:

  • *TickerBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickerBuilder().TickerData(nil)

type Tickers 

type Tickers struct {
	// contains filtered or unexported fields
}

Tickers represents a collection of financial tickers with methods for retrieving aggregated data and analytics. It encapsulates a handle to the underlying C library for interacting with multiple tickers.

func (*Tickers) Free 

func (t *Tickers) Free()

Free releases the resources associated with the Tickers. It should be called when the Tickers is no longer needed to prevent memory leaks.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	tickers.Free()
	fmt.Println("Tickers resources freed successfully")
}

func (*Tickers) GetBalanceSheet 

func (t *Tickers) GetBalanceSheet(frequency string, formatted bool) (dataframe.DataFrame, error)

GetBalanceSheet retrieves the balance sheets for the tickers.

Parameters:

  • frequency: The frequency of the statement ("annual" or "quarterly").
  • formatted: Whether to return the statement in a formatted manner.

Returns:

  • dataframe.DataFrame: A DataFrame containing aggregated balance sheet data for all tickers.
  • error: An error if the balance sheet retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	balance, err := tickers.GetBalanceSheet("quarterly", true)
	if err != nil {
		fmt.Printf("Failed to get balance sheet: %v\n", err)
		return
	}
	fmt.Printf("Balance Sheet:\n%v\n", balance)
}

func (*Tickers) GetCashflowStatement 

func (t *Tickers) GetCashflowStatement(frequency string, formatted bool) (dataframe.DataFrame, error)

GetCashflowStatement retrieves the cash flow statements for the tickers.

Parameters:

  • frequency: The frequency of the statement ("annual" or "quarterly").
  • formatted: Whether to return the statement in a formatted manner.

Returns:

  • dataframe.DataFrame: A DataFrame containing aggregated cash flow statement data for all tickers.
  • error: An error if the cash flow statement retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	cashflow, err := tickers.GetCashflowStatement("quarterly", true)
	if err != nil {
		fmt.Printf("Failed to get cash flow statement: %v\n", err)
		return
	}
	fmt.Printf("Cash Flow Statement:\n%v\n", cashflow)
}

func (*Tickers) GetFinancialRatios 

func (t *Tickers) GetFinancialRatios(frequency string) (dataframe.DataFrame, error)

GetFinancialRatios retrieves financial ratios for the tickers.

Parameters:

  • frequency: The frequency of the ratios ("annual" or "quarterly").

Returns:

  • dataframe.DataFrame: A DataFrame containing aggregated financial ratios for all tickers.
  • error: An error if the financial ratios retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	ratios, err := tickers.GetFinancialRatios("quarterly")
	if err != nil {
		fmt.Printf("Failed to get financial ratios: %v\n", err)
		return
	}
	fmt.Printf("Financial Ratios:\n%v\n", ratios)
}

func (*Tickers) GetIncomeStatement 

func (t *Tickers) GetIncomeStatement(frequency string, formatted bool) (dataframe.DataFrame, error)

GetIncomeStatement retrieves the income statements for the tickers.

Parameters:

  • frequency: The frequency of the statement ("annual" or "quarterly").
  • formatted: Whether to return the statement in a formatted manner.

Returns:

  • dataframe.DataFrame: A DataFrame containing aggregated income statement data for all tickers.
  • error: An error if the income statement retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	income, err := tickers.GetIncomeStatement("quarterly", true)
	if err != nil {
		fmt.Printf("Failed to get income statement: %v\n", err)
		return
	}
	fmt.Printf("Income Statement:\n%v\n", income)
}

func (*Tickers) GetNews 

func (t *Tickers) GetNews() (dataframe.DataFrame, error)

GetNews retrieves the latest news headlines for the tickers.

Returns:

  • dataframe.DataFrame: A DataFrame containing aggregated news data for all tickers.
  • error: An error if the news retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	news, err := tickers.GetNews()
	if err != nil {
		fmt.Printf("Failed to get news: %v\n", err)
		return
	}
	fmt.Printf("News:\n%v\n", news)
}

func (*Tickers) GetOptionsChain 

func (t *Tickers) GetOptionsChain() (dataframe.DataFrame, error)

GetOptionsChain retrieves the options chain for the tickers.

Returns:

  • dataframe.DataFrame: A DataFrame containing aggregated options chain data for all tickers.
  • error: An error if the options chain retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	options, err := tickers.GetOptionsChain()
	if err != nil {
		fmt.Printf("Failed to get options chain: %v\n", err)
		return
	}
	fmt.Printf("Options Chain:\n%v\n", options)
}

func (*Tickers) GetPriceHistory 

func (t *Tickers) GetPriceHistory() (dataframe.DataFrame, error)

GetPriceHistory retrieves the OHLCV (Open, High, Low, Close, Volume) price history for the tickers.

Returns:

  • dataframe.DataFrame: A DataFrame containing aggregated price history data for all tickers.
  • error: An error if the price history retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	history, err := tickers.GetPriceHistory()
	if err != nil {
		fmt.Printf("Failed to get price history: %v\n", err)
		return
	}
	fmt.Printf("Price History:\n%v\n", history)
}

func (*Tickers) GetSummaryStats 

func (t *Tickers) GetSummaryStats() (dataframe.DataFrame, error)

GetSummaryStats retrieves summary technical and fundamental statistics for the tickers.

Returns:

  • dataframe.DataFrame: A DataFrame containing aggregated summary statistics for all tickers.
  • error: An error if the statistics retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	summary, err := tickers.GetSummaryStats()
	if err != nil {
		fmt.Printf("Failed to get summary stats: %v\n", err)
		return
	}
	fmt.Printf("Summary Stats:\n%v\n", summary)
}

func (*Tickers) GetTicker 

func (t *Tickers) GetTicker(symbol string) (*Ticker, error)

GetTicker retrieves a Ticker instance for a specific symbol from the Tickers collection.

Parameters:

  • symbol: The ticker symbol to retrieve (e.g., "AAPL").

Returns:

  • *Ticker: A pointer to the Ticker object for the specified symbol.
  • error: An error if the Ticker retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	ticker, err := tickers.GetTicker("AAPL")
	if err != nil {
		fmt.Printf("Failed to get Ticker: %v\n", err)
		return
	}
	defer ticker.Free()
	fmt.Println("Successfully retrieved Ticker for AAPL")
}

func (*Tickers) Optimize 

func (t *Tickers) Optimize(objectiveFunction, assetConstraints, categoricalConstraints, weights string) (*Portfolio, error)

Optimize optimizes the portfolio of tickers based on the specified objective and constraints.

Parameters:

  • objectiveFunction: The objective function for optimization (e.g., "max_sharpe").
  • assetConstraints: JSON string defining asset-level constraints (e.g., "{}").
  • categoricalConstraints: JSON string defining categorical constraints (e.g., "{}").
  • weights: JSON string defining portfolio-level constraints (e.g., "{}").

Returns:

  • *Portfolio: A pointer to the optimized Portfolio object.
  • error: An error if the portfolio optimization fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		BenchmarkSymbol("^GSPC").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	portfolio, err := tickers.Optimize("max_sharpe", "{}", "{}", "{}")
	if err != nil {
		fmt.Printf("Failed to optimize portfolio: %v\n", err)
		return
	}
	defer portfolio.Free()
	fmt.Println("Successfully optimized portfolio")
}

func (*Tickers) PerformanceStats 

func (t *Tickers) PerformanceStats() (dataframe.DataFrame, error)

PerformanceStats retrieves performance statistics for the tickers.

Returns:

  • dataframe.DataFrame: A DataFrame containing aggregated performance statistics for all tickers (e.g., returns, volatility, Sharpe ratio).
  • error: An error if the performance statistics retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		BenchmarkSymbol("^GSPC").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	perfStats, err := tickers.PerformanceStats()
	if err != nil {
		fmt.Printf("Failed to get performance stats: %v\n", err)
		return
	}
	fmt.Printf("Performance Stats:\n%v\n", perfStats)
}

func (*Tickers) Report 

func (t *Tickers) Report(reportType string) (HTML, error)

Report retrieves a comprehensive analytics report for the tickers as an HTML object.

Parameters:

  • reportType: The type of report to display (e.g., "performance", "financials", "options", "news").

Returns:

  • HTML: An HTML object containing the report.
  • error: An error if the report retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		BenchmarkSymbol("^GSPC").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	report, err := tickers.Report("performance")
	if err != nil {
		fmt.Printf("Failed to get report: %v\n", err)
		return
	}
	report.Show()
}

func (*Tickers) Returns 

func (t *Tickers) Returns() (dataframe.DataFrame, error)

Returns retrieves returns data for the tickers.

Returns:

  • dataframe.DataFrame: A DataFrame containing returns data for all tickers.
  • error: An error if the returns retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
	"github.com/go-gota/gota/dataframe"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	returns, err := tickers.Returns()
	if err != nil {
		fmt.Printf("Failed to get returns: %v\n", err)
		return
	}
	fmt.Printf("Returns:\n%v\n", returns)
}

func (*Tickers) ReturnsChart 

func (t *Tickers) ReturnsChart(height, width uint) (HTML, error)

ReturnsChart retrieves the returns chart for the tickers as an HTML object.

Parameters:

  • height: The height of the chart (0 for default).
  • width: The width of the chart (0 for default).

Returns:

  • HTML: An HTML object containing the returns chart.
  • error: An error if the chart retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	retChart, err := tickers.ReturnsChart(0, 0)
	if err != nil {
		fmt.Printf("Failed to get returns chart: %v\n", err)
		return
	}
	retChart.Show()
}

func (*Tickers) ReturnsMatrix 

func (t *Tickers) ReturnsMatrix(height, width uint) (HTML, error)

ReturnsMatrix retrieves the returns correlation matrix for the tickers as an HTML object.

Parameters:

  • height: The height of the chart (0 for default).
  • width: The width of the chart (0 for default).

Returns:

  • HTML: An HTML object containing the returns correlation matrix.
  • error: An error if the matrix retrieval fails.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()

	retMatrix, err := tickers.ReturnsMatrix(0, 0)
	if err != nil {
		fmt.Printf("Failed to get returns matrix: %v\n", err)
		return
	}
	retMatrix.Show()
}

type TickersBuilder 

type TickersBuilder struct {
	// contains filtered or unexported fields
}

TickersBuilder is used to construct a Tickers instance using the builder pattern. It allows for fluent configuration of the Tickers' parameters before creation.

func NewTickersBuilder 

func NewTickersBuilder() *TickersBuilder

NewTickersBuilder initializes a new TickersBuilder with default values. Defaults:

  • symbols: nil
  • startDate: ""
  • endDate: ""
  • interval: "1d"
  • benchmarkSymbol: ""
  • confidenceLevel: 0.95
  • riskFreeRate: 0.02
  • tickersData: nil
  • benchmarkData: nil

Returns:

  • *TickersBuilder: A pointer to the initialized TickersBuilder.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	builder := finalytics.NewTickersBuilder()
	fmt.Println("TickersBuilder initialized")
}

func (*TickersBuilder) BenchmarkData 

func (b *TickersBuilder) BenchmarkData(benchmarkData *dataframe.DataFrame) *TickersBuilder

BenchmarkData sets custom benchmark data for the Tickers.

Parameters:

  • benchmarkData: A DataFrame containing custom benchmark data (pass nil if not using custom data).

Returns:

  • *TickersBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickersBuilder().BenchmarkData(nil)

func (*TickersBuilder) BenchmarkSymbol 

func (b *TickersBuilder) BenchmarkSymbol(benchmarkSymbol string) *TickersBuilder

BenchmarkSymbol sets the benchmark symbol for the Tickers.

Parameters:

  • benchmarkSymbol: The ticker symbol of the benchmark (e.g., "^GSPC").

Returns:

  • *TickersBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickersBuilder().BenchmarkSymbol("^GSPC")

func (*TickersBuilder) Build 

func (b *TickersBuilder) Build() (*Tickers, error)

Build constructs the Tickers instance with the configured parameters. The symbols parameter is required; other parameters are optional and use defaults if not set.

Returns:

  • *Tickers: A pointer to the initialized Tickers object.
  • error: An error if the Tickers creation fails or symbols is missing/empty.

Example: 

package main

import (
	"fmt"
	"github.com/Nnamdi-sys/finalytics/go/finalytics"
)

func main() {
	tickers, err := finalytics.NewTickersBuilder().
		Symbols([]string{"AAPL", "MSFT"}).
		StartDate("2023-01-01").
		EndDate("2023-12-31").
		Interval("1d").
		BenchmarkSymbol("^GSPC").
		ConfidenceLevel(0.95).
		RiskFreeRate(0.02).
		Build()
	if err != nil {
		fmt.Printf("Failed to create Tickers: %v\n", err)
		return
	}
	defer tickers.Free()
	fmt.Println("Tickers created successfully for AAPL and MSFT")
}

func (*TickersBuilder) ConfidenceLevel 

func (b *TickersBuilder) ConfidenceLevel(confidenceLevel float64) *TickersBuilder

ConfidenceLevel sets the confidence level for VaR and ES calculations.

Parameters:

  • confidenceLevel: The confidence level (e.g., 0.95 for 95% confidence).

Returns:

  • *TickersBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickersBuilder().ConfidenceLevel(0.99)

func (*TickersBuilder) EndDate 

func (b *TickersBuilder) EndDate(endDate string) *TickersBuilder

EndDate sets the end date for the Tickers' data period.

Parameters:

  • endDate: The end date in the format YYYY-MM-DD.

Returns:

  • *TickersBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickersBuilder().EndDate("2023-12-31")

func (*TickersBuilder) Interval 

func (b *TickersBuilder) Interval(interval string) *TickersBuilder

Interval sets the data interval for the Tickers.

Parameters:

  • interval: The data interval (e.g., "2m", "5m", "15m", "30m", "1h", "1d", "1wk", "1mo", "3mo").

Returns:

  • *TickersBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickersBuilder().Interval("1d")

func (*TickersBuilder) RiskFreeRate 

func (b *TickersBuilder) RiskFreeRate(riskFreeRate float64) *TickersBuilder

RiskFreeRate sets the risk-free rate for calculations.

Parameters:

  • riskFreeRate: The risk-free rate (e.g., 0.02 for 2%).

Returns:

  • *TickersBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickersBuilder().RiskFreeRate(0.03)

func (*TickersBuilder) StartDate 

func (b *TickersBuilder) StartDate(startDate string) *TickersBuilder

StartDate sets the start date for the Tickers' data period.

Parameters:

  • startDate: The start date in the format YYYY-MM-DD.

Returns:

  • *TickersBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickersBuilder().StartDate("2023-01-01")

func (*TickersBuilder) Symbols 

func (b *TickersBuilder) Symbols(symbols []string) *TickersBuilder

Symbols sets the ticker symbols for the Tickers.

Parameters:

  • symbols: A string slice of ticker symbols (e.g., []string{"AAPL", "MSFT"}).

Returns:

  • *TickersBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickersBuilder().Symbols([]string{"AAPL", "MSFT"})

func (*TickersBuilder) TickersData 

func (b *TickersBuilder) TickersData(tickersData []dataframe.DataFrame) *TickersBuilder

TickersData sets custom ticker data for the Tickers.

Parameters:

  • tickersData: A slice of DataFrames containing custom ticker data for each symbol (pass nil or empty slice if not using custom data).

Returns:

  • *TickersBuilder: The builder instance for method chaining.

Example: 

builder := finalytics.NewTickersBuilder().TickersData(nil)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.