strategy

May 29, 2026 ยท View on GitHub

import "github.com/cinar/indicator/v2/strategy"

Package strategy contains the strategy functions.

This package belongs to the Indicator project. Indicator is a Golang module that supplies a variety of technical indicators, strategies, and a backtesting framework for analysis.

License

Copyright (c) 2021-2026 Onur Cinar.
The source code is provided under GNU AGPLv3 License.
https://github.com/cinar/indicator

Disclaimer

The information provided on this project is strictly for informational purposes and is not to be construed as advice or solicitation to buy or sell any security.

Index

func ActionSources

func ActionSources(strategies []Strategy, snapshots <-chan *asset.Snapshot) []<-chan Action

ActionSources creates a slice of action channels, one for each strategy, where each channel emits actions computed by its corresponding strategy based on snapshots from the provided snapshot channel.

func ActionsToAnnotations

func ActionsToAnnotations(ac <-chan Action) <-chan string

ActionsToAnnotations takes a channel of action recommendations and returns a new channel containing corresponding annotations for those actions.

Deprecated: Use ActionsToAnnotationsWithContext instead.

func ActionsToAnnotationsWithContext

func ActionsToAnnotationsWithContext(ctx context.Context, ac <-chan Action) <-chan string

ActionsToAnnotationsWithContext takes a channel of action recommendations and returns a new channel containing corresponding annotations for those actions, supporting context cancellation.

func ComputeStrategyWithContext

func ComputeStrategyWithContext(ctx context.Context, s Strategy, c <-chan *asset.Snapshot) <-chan Action

ComputeStrategyWithContext processes snapshots with a strategy using context.

func ComputeWithOutcome

func ComputeWithOutcome(s Strategy, c <-chan *asset.Snapshot) (<-chan Action, <-chan float64)

ComputeWithOutcome uses the given strategy to processes the provided asset snapshots and generates a stream of actionable recommendations and outcomes.

Deprecated: Use ComputeWithOutcomeWithContext instead.

func ComputeWithOutcomeWithContext

func ComputeWithOutcomeWithContext(ctx context.Context, s Strategy, c <-chan *asset.Snapshot) (<-chan Action, <-chan float64)

ComputeWithOutcomeWithContext uses the given strategy to processes the provided asset snapshots and generates a stream of actionable recommendations and outcomes, supporting context cancellation.

func CountActions

func CountActions(acs []<-chan Action) (int, int, int, bool)

CountActions taken a slice of Action channels, and counts them by their type.

func CountTransactions

func CountTransactions(ac <-chan Action) <-chan int

CountTransactions counts the number of recommended Buy and Sell actions.

func DenormalizeActions

func DenormalizeActions(ac <-chan Action) <-chan Action

DenormalizeActions simplifies the representation of the action sequence.

Deprecated: Use DenormalizeActionsWithContext instead.

func DenormalizeActionsWithContext

func DenormalizeActionsWithContext(ctx context.Context, ac <-chan Action) <-chan Action

DenormalizeActionsWithContext simplifies the representation of the action sequence and facilitates subsequent processing by transforming the given channel of actions, supporting context cancellation.

func NormalizeActions

func NormalizeActions(ac <-chan Action) <-chan Action

NormalizeActions transforms the given channel of actions to ensure a consistent and predictable sequence.

Deprecated: Use NormalizeActionsWithContext instead.

func NormalizeActionsWithContext

func NormalizeActionsWithContext(ctx context.Context, ac <-chan Action) <-chan Action

NormalizeActionsWithContext transforms the given channel of actions to ensure a consistent and predictable sequence, supporting context cancellation.

func Outcome

func Outcome[T helper.Number](values <-chan T, actions <-chan Action) <-chan float64

Outcome simulates the potential result of executing the given actions based on the provided values.

Deprecated: Use OutcomeWithContext instead.

func OutcomeWithContext

func OutcomeWithContext[T helper.Number](ctx context.Context, values <-chan T, actions <-chan Action) <-chan float64

OutcomeWithContext simulates the potential result of executing the given actions based on the provided values, supporting context cancellation.

type Action

Action represents the different action categories that a strategy can recommend.

type Action int


const (
    // Hold suggests maintaining the current position and not
    // taking any actions on the asset.
    Hold Action = 0

    // Sell suggests disposing of the asset and exiting the current position.
    // This recommendation typically indicates that the strategy believes the
    // asset's price has reached its peak or is likely to decline.
    Sell Action = -1

    // Buy suggests acquiring the asset and entering a new position. This
    // recommendation usually implies that the strategy believes the
    // asset's price is undervalued.
    Buy Action = 1
)

func (Action) Annotation

func (a Action) Annotation() string

Annotation returns a single character string representing the recommended action. It returns "S" for Sell, "B" for Buy, and an empty string for Hold.

type AndStrategy

AndStrategy combines multiple strategies and emits actionable recommendations when **all** strategies in the group **reach the same actionable conclusion**. This can be a conservative approach, potentially delaying recommendations until full consensus is reached.

type AndStrategy struct {
    // Strategies are the group of strategies that will be consulted to make an actionable recommendation.
    Strategies []Strategy
    // contains filtered or unexported fields
}

func NewAndStrategy

func NewAndStrategy(name string, strategies ...Strategy) *AndStrategy

NewAndStrategy function initializes an empty and strategies group with the given name.

func (*AndStrategy) Compute

func (a *AndStrategy) Compute(snapshots <-chan *asset.Snapshot) <-chan Action

Compute wraps ComputeWithContext for backwards compatibility.

Deprecated: Use ComputeWithContext instead.

func (*AndStrategy) ComputeWithContext

func (a *AndStrategy) ComputeWithContext(ctx context.Context, snapshots <-chan *asset.Snapshot) <-chan Action

ComputeWithContext processes the provided asset snapshots and generates a stream of actionable recommendations.

func (*AndStrategy) Name

func (a *AndStrategy) Name() string

Name returns the name of the strategy.

func (*AndStrategy) Report

func (a *AndStrategy) Report(c <-chan *asset.Snapshot) *helper.Report

Report processes the provided asset snapshots and generates a report annotated with the recommended actions.

type BuyAndHoldStrategy

BuyAndHoldStrategy defines an investment approach of acquiring and indefinitely retaining an asset. This strategy primarily serves as a benchmark for evaluating the performance of alternative strategies against a baseline of passive asset ownership.

type BuyAndHoldStrategy struct {
}

func NewBuyAndHoldStrategy

func NewBuyAndHoldStrategy() *BuyAndHoldStrategy

NewBuyAndHoldStrategy function initializes a new buy and hold strategy instance.

func (*BuyAndHoldStrategy) Compute

func (i *BuyAndHoldStrategy) Compute(snapshots <-chan *asset.Snapshot) <-chan Action

Compute wraps ComputeWithContext for backwards compatibility.

Deprecated: Use ComputeWithContext instead.

func (*BuyAndHoldStrategy) ComputeWithContext

func (i *BuyAndHoldStrategy) ComputeWithContext(ctx context.Context, snapshots <-chan *asset.Snapshot) <-chan Action

ComputeWithContext processes the provided asset snapshots and generates a stream of actionable recommendations.

func (*BuyAndHoldStrategy) Name

func (*BuyAndHoldStrategy) Name() string

Name returns the name of the strategy.

func (*BuyAndHoldStrategy) Report

func (b *BuyAndHoldStrategy) Report(c <-chan *asset.Snapshot) *helper.Report

Report processes the provided asset snapshots and generates a report annotated with the recommended actions.

type MajorityStrategy

MajorityStrategy emits actionable recommendations aligned with what the strategies in the group recommends.

type MajorityStrategy struct {
    // Strategies are the group of strategies that will be consulted to make an actionable recommendation.
    Strategies []Strategy
    // contains filtered or unexported fields
}

func NewMajorityStrategy

func NewMajorityStrategy(name string) *MajorityStrategy

NewMajorityStrategy function initializes an empty majority strategies group with the given name.

func NewMajorityStrategyWith

func NewMajorityStrategyWith(name string, strategies []Strategy) *MajorityStrategy

NewMajorityStrategyWith function initializes a majority strategies group with the given name and strategies.

func (*MajorityStrategy) Compute

func (a *MajorityStrategy) Compute(snapshots <-chan *asset.Snapshot) <-chan Action

Compute wraps ComputeWithContext for backwards compatibility.

Deprecated: Use ComputeWithContext instead.

func (*MajorityStrategy) ComputeWithContext

func (a *MajorityStrategy) ComputeWithContext(ctx context.Context, snapshots <-chan *asset.Snapshot) <-chan Action

ComputeWithContext processes the provided asset snapshots and generates a stream of actionable recommendations.

func (*MajorityStrategy) Name

func (a *MajorityStrategy) Name() string

Name returns the name of the strategy.

func (*MajorityStrategy) Report

func (a *MajorityStrategy) Report(c <-chan *asset.Snapshot) *helper.Report

Report processes the provided asset snapshots and generates a report annotated with the recommended actions.

type OrStrategy

OrStrategy emits actionable recommendations when **at least one** strategy in the group recommends an action **without any conflicting recommendations** from other strategies.

type OrStrategy struct {
    // Strategies are the group of strategies that will be consulted to make an actionable recommendation.
    Strategies []Strategy
    // contains filtered or unexported fields
}

func NewOrStrategy

func NewOrStrategy(name string, strategies ...Strategy) *OrStrategy

NewOrStrategy function initializes an empty or strategies group with the given name.

func (*OrStrategy) Compute

func (a *OrStrategy) Compute(snapshots <-chan *asset.Snapshot) <-chan Action

Compute wraps ComputeWithContext for backwards compatibility.

Deprecated: Use ComputeWithContext instead.

func (*OrStrategy) ComputeWithContext

func (a *OrStrategy) ComputeWithContext(ctx context.Context, snapshots <-chan *asset.Snapshot) <-chan Action

ComputeWithContext processes the provided asset snapshots and generates a stream of actionable recommendations.

func (*OrStrategy) Name

func (a *OrStrategy) Name() string

Name returns the name of the strategy.

func (*OrStrategy) Report

func (a *OrStrategy) Report(c <-chan *asset.Snapshot) *helper.Report

Report processes the provided asset snapshots and generates a report annotated with the recommended actions.

type Result

Result is only used inside the test cases to facilitate the comparison between the actual and expected strategy results.

type Result struct {
    Action Action
}

type SplitStrategy

SplitStrategy leverages two separate strategies. It utilizes the first strategy to identify potential Buy opportunities, and the second strategy to identify potential Sell opportunities. When there is a conflicting recommendation, returns Hold.

type SplitStrategy struct {
    // BuyStrategy is used to identify potential Buy opportunities.
    BuyStrategy Strategy

    // SellStrategy is used to identify potential Sell opportunities.
    SellStrategy Strategy
}

func NewSplitStrategy

func NewSplitStrategy(buyStrategy, sellStrategy Strategy) *SplitStrategy

NewSplitStrategy function initializes a new split strategy with the given parameters.

func (*SplitStrategy) Compute

func (s *SplitStrategy) Compute(snapshots <-chan *asset.Snapshot) <-chan Action

Compute wraps ComputeWithContext for backwards compatibility.

Deprecated: Use ComputeWithContext instead.

func (*SplitStrategy) ComputeWithContext

func (s *SplitStrategy) ComputeWithContext(ctx context.Context, snapshots <-chan *asset.Snapshot) <-chan Action

ComputeWithContext processes the provided asset snapshots and generates a stream of actionable recommendations.

func (*SplitStrategy) Name

func (s *SplitStrategy) Name() string

Name returns the name of the strategy.

func (*SplitStrategy) Report

func (s *SplitStrategy) Report(c <-chan *asset.Snapshot) *helper.Report

Report processes the provided asset snapshots and generates a report annotated with the recommended actions.

type Strategy

Strategy defines a shared interface for trading strategies.

type Strategy interface {
    // Name returns the name of the strategy.
    Name() string

    // Compute processes the provided asset snapshots and generates a
    // stream of actionable recommendations.
    Compute(snapshots <-chan *asset.Snapshot) <-chan Action

    // Report processes the provided asset snapshots and generates a
    // report annotated with the recommended actions.
    Report(snapshots <-chan *asset.Snapshot) *helper.Report
}

func AllAndStrategies

func AllAndStrategies(strategies []Strategy) []Strategy

AllAndStrategies performs a cartesian product operation on the given strategies, resulting in a collection containing all and strategies formed by combining two strategies together.

func AllSplitStrategies

func AllSplitStrategies(strategies []Strategy) []Strategy

AllSplitStrategies performs a cartesian product operation on the given strategies, resulting in a collection containing all split strategies formed by combining individual buy and sell strategies.

func AllStrategies

func AllStrategies() []Strategy

AllStrategies returns a slice containing references to all available base strategies.

type StrategyWithContext

StrategyWithContext defines a shared interface for trading strategies supporting context-aware computations.

type StrategyWithContext interface {
    Strategy
    ComputeWithContext(ctx context.Context, snapshots <-chan *asset.Snapshot) <-chan Action
}

Generated by gomarkdoc