finalytics

package
v0.2.0 Latest Latest
Warning

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

 Go to latest Published: May 1, 2026 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) PortfolioValueChart added in v0.2.0 

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

PortfolioValueChart retrieves the portfolio value over time 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 portfolio value chart.
  • error: An error if the chart retrieval fails.

func (*Portfolio) Report 

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

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()
}

func (*Portfolio) TransactionHistory added in v0.2.0 

func (p *Portfolio) TransactionHistory() (dataframe.DataFrame, error)

TransactionHistory retrieves the transaction history table for the portfolio.

Returns a table of all transaction events during the simulation, including rebalances, cash flows, and combined events. Each row includes portfolio value before/after, per-asset values, trade amounts, turnover, cumulative TWR and MWR.

Returns:

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

func (*Portfolio) UpdateDates added in v0.2.0 

func (p *Portfolio) UpdateDates(startDate, endDate string) 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()
}

UpdateDates updates the portfolio's date range and re-fetches data for out-of-sample evaluation.

This method is for portfolios built from Yahoo Finance data (not custom data). It rebuilds all underlying ticker and benchmark data for the new date range. The optimization result (weights) is preserved so they can be evaluated out-of-sample on the new period.

After calling this method, call PerformanceStats() to evaluate the optimized weights on the new data (it recomputes automatically).

Parameters:

  • startDate: New start date (e.g., "2024-01-01").
  • endDate: New end date (e.g., "2024-12-31").

Returns:

  • error: An error if the update fails.

Example: 

portfolio.UpdateDates("2024-01-01", "2024-12-31")
stats, _ := portfolio.PerformanceStats()
fmt.Println(stats)

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. Supported values: "max_sharpe", "max_sortino", "max_return", "min_vol", "min_var", "min_cvar", "min_drawdown", "risk_parity", "max_diversification", "hierarchical_risk_parity"

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

Example: 

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

func (*PortfolioBuilder) RebalanceStrategy added in v0.2.0 

func (b *PortfolioBuilder) RebalanceStrategy(rebalanceStrategy string) *PortfolioBuilder

RebalanceStrategy sets the rebalancing strategy for the portfolio simulation.

Parameters:

  • rebalanceStrategy: JSON string defining the strategy. Formats: `{"type":"calendar","frequency":"monthly"}` — rebalance on a fixed calendar schedule `{"type":"threshold","threshold":0.05}` — rebalance when any weight drifts > threshold `{"type":"calendar_or_threshold","frequency":"quarterly","threshold":0.05}` — either trigger Frequency values: "monthly", "quarterly", "semi_annually", "annually"

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

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) ScheduledCashFlows added in v0.2.0 

func (b *PortfolioBuilder) ScheduledCashFlows(scheduledCashFlows string) *PortfolioBuilder

ScheduledCashFlows sets recurring cash flow schedules for the portfolio simulation.

Parameters:

  • scheduledCashFlows: JSON string defining the schedules. Format: `[{"amount":2000,"frequency":"monthly","start_date":null,"end_date":null,"allocation":"pro_rata"}]` Amount: positive = addition, negative = withdrawal. Allocation: "pro_rata", "rebalance", or {"custom":[0.4,0.3,0.2,0.1]}

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

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) Transactions added in v0.2.0 

func (b *PortfolioBuilder) Transactions(transactions string) *PortfolioBuilder

Transactions sets ad-hoc per-asset transactions (additions / withdrawals).

Parameters:

  • transactions: JSON string defining transactions. Format: `[{"date":"2024-01-15","ticker":"AAPL","amount":5000},{"date":"2024-06-01","ticker":"MSFT","amount":-2000}]` Positive amounts are additions, negative are withdrawals.

Returns:

  • *PortfolioBuilder: The builder instance for method chaining.

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) Display added in v0.2.0 

func (s *Screener) Display() error

Display renders the screener overview and metrics as an HTML report and opens it in the default browser.

Returns:

  • error: An error if the display retrieval or browser launch fails.

Example: 

screener, err := finalytics.NewScreenerBuilder().
    QuoteType("EQUITY").
    AddFilter(`{"operator":"eq","operands":["exchange","NMS"]}`).
    SortField("intradaymarketcap").
    Size(10).
    Build()
if err != nil {
    panic(err)
}
defer screener.Free()
screener.Display()

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 ScreenerBuilder added in v0.2.0 

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

ScreenerBuilder provides a fluent builder interface for constructing a Screener. Use NewScreenerBuilder() to create a new builder, then chain methods to configure it, and call Build() to create the Screener.

Defaults:

  • quoteType: "EQUITY"
  • filters: [] (empty)
  • sortField: "" (no sorting)
  • sortDescending: true
  • offset: 0
  • size: 250

func NewScreenerBuilder added in v0.2.0 

func NewScreenerBuilder() *ScreenerBuilder

NewScreenerBuilder initializes a new ScreenerBuilder with default values.

Returns:

  • *ScreenerBuilder: A pointer to the initialized ScreenerBuilder.

Example: 

screener, err := finalytics.NewScreenerBuilder().
    QuoteType("EQUITY").
    AddFilter(`{"operator":"eq","operands":["exchange","NMS"]}`).
    SortField("intradaymarketcap").
    SortDescending(true).
    Size(10).
    Build()

func (*ScreenerBuilder) AddFilter added in v0.2.0 

func (b *ScreenerBuilder) AddFilter(filter string) *ScreenerBuilder

AddFilter appends a filter condition to the screener. Each filter should be a JSON string with the format: 

{"operator": "<op>", "operands": ["<metric>", <value>]}

Supported operators: "eq", "gte", "lte", "gt", "lt", "btwn".

Parameters:

  • filter: A JSON string representing a single filter condition.

Returns:

  • *ScreenerBuilder: The builder instance for method chaining.

Example: 

builder.AddFilter(`{"operator":"eq","operands":["exchange","NMS"]}`)
builder.AddFilter(`{"operator":"gte","operands":["intradaymarketcap",10000000000]}`)

func (*ScreenerBuilder) Build added in v0.2.0 

func (b *ScreenerBuilder) Build() (*Screener, error)

Build constructs a Screener with the configured parameters by calling the underlying FFI.

Returns:

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

Example: 

screener, err := finalytics.NewScreenerBuilder().
    QuoteType("EQUITY").
    AddFilter(`{"operator":"eq","operands":["exchange","NMS"]}`).
    AddFilter(`{"operator":"eq","operands":["sector","Technology"]}`).
    AddFilter(`{"operator":"gte","operands":["intradaymarketcap",10000000000]}`).
    AddFilter(`{"operator":"gte","operands":["returnonequity.lasttwelvemonths",0.15]}`).
    SortField("intradaymarketcap").
    SortDescending(true).
    Offset(0).
    Size(10).
    Build()
if err != nil {
    panic(err)
}
defer screener.Free()

func (*ScreenerBuilder) Offset added in v0.2.0 

func (b *ScreenerBuilder) Offset(offset uint) *ScreenerBuilder

Offset sets the starting index for pagination.

Parameters:

  • offset: The starting index (e.g., 0 for the first page).

Returns:

  • *ScreenerBuilder: The builder instance for method chaining.

func (*ScreenerBuilder) QuoteType added in v0.2.0 

func (b *ScreenerBuilder) QuoteType(quoteType string) *ScreenerBuilder

QuoteType sets the type of financial instrument to screen.

Parameters:

  • quoteType: The quote type (e.g., "EQUITY", "MUTUALFUND", "ETF", "INDEX", "FUTURE", "CRYPTO").

Returns:

  • *ScreenerBuilder: The builder instance for method chaining.

func (*ScreenerBuilder) Size added in v0.2.0 

func (b *ScreenerBuilder) Size(size uint) *ScreenerBuilder

Size sets the maximum number of results to return.

Parameters:

  • size: The maximum number of results (e.g., 10 for top 10).

Returns:

  • *ScreenerBuilder: The builder instance for method chaining.

func (*ScreenerBuilder) SortDescending added in v0.2.0 

func (b *ScreenerBuilder) SortDescending(descending bool) *ScreenerBuilder

SortDescending sets whether to sort in descending order.

Parameters:

  • descending: true for descending order, false for ascending order.

Returns:

  • *ScreenerBuilder: The builder instance for method chaining.

func (*ScreenerBuilder) SortField added in v0.2.0 

func (b *ScreenerBuilder) SortField(sortField string) *ScreenerBuilder

SortField sets the metric to sort results by.

Parameters:

  • sortField: The metric name to sort by (e.g., "intradaymarketcap"). Use "" for no sorting.

Returns:

  • *ScreenerBuilder: The builder instance for method chaining.

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.