コード例 #1
0
 /// <summary>
 /// Yields all possible matches for this leg definition held within the collection of <paramref name="positions"/>
 /// </summary>
 /// <param name="options">Strategy matcher options guiding matching behaviors</param>
 /// <param name="legs">The preceding legs already matched for the parent strategy definition</param>
 /// <param name="positions">The remaining, unmatched positions available to be matched against</param>
 /// <returns>An enumerable of potential matches</returns>
 public IEnumerable <OptionStrategyLegDefinitionMatch> Match(
     OptionStrategyMatcherOptions options,
     IReadOnlyList <OptionPosition> legs,
     OptionPositionCollection positions
     )
 {
     foreach (var position in options.Enumerate(Filter(legs, positions, false)))
     {
         var multiplier = position.Quantity / Quantity;
         if (multiplier != 0)
         {
             yield return(new OptionStrategyLegDefinitionMatch(multiplier,
                                                               position.WithQuantity(multiplier * Quantity)
                                                               ));
         }
     }
 }
コード例 #2
0
        private IEnumerable <OptionStrategyDefinitionMatch> Match(
            OptionStrategyMatcherOptions options,
            ImmutableList <OptionStrategyLegDefinitionMatch> legMatches,
            ImmutableList <OptionPosition> legPositions,
            OptionPositionCollection positions,
            int multiplier
            )
        {
            var nextLegIndex = legPositions.Count;

            if (nextLegIndex == Legs.Count)
            {
                if (nextLegIndex > 0)
                {
                    yield return(new OptionStrategyDefinitionMatch(this, legMatches, multiplier));
                }
            }
            else if (positions.Count >= LegCount - nextLegIndex)
            {
                // grab the next leg definition and perform the match, restricting total to configured maximum per leg
                var nextLeg     = Legs[nextLegIndex];
                var maxLegMatch = options.GetMaximumLegMatches(nextLegIndex);
                foreach (var legMatch in nextLeg.Match(options, legPositions, positions).Take(maxLegMatch))
                {
                    // add match to the match we're constructing and deduct matched position from positions collection
                    // we track the min multiplier in line so when we're done, we have the total number of matches for
                    // the matched set of positions in this 'thread' (OptionStrategy.Quantity)
                    foreach (var definitionMatch in Match(options,
                                                          legMatches.Add(legMatch),
                                                          legPositions.Add(legMatch.Position),
                                                          positions - legMatch.Position,
                                                          Math.Min(multiplier, legMatch.Multiplier)
                                                          ))
                    {
                        yield return(definitionMatch);
                    }
                }
            }
            else
            {
                // positions.Count < LegsCount indicates a failed match

                // could include partial matches, would allow an algorithm to determine if adding a
                // new position could help reduce overall margin exposure by completing a strategy
            }
        }
コード例 #3
0
        /// <summary>
        /// Determines all possible matches for this definition using the provided <paramref name="positions"/>.
        /// This includes OVERLAPPING matches. It's up to the actual matcher to make decisions based on which
        /// matches to accept. This allows the matcher to prioritize matching certain positions over others.
        /// </summary>
        public IEnumerable <OptionStrategyDefinitionMatch> Match(
            OptionStrategyMatcherOptions options,
            OptionPositionCollection positions
            )
        {
            // TODO : Pass OptionStrategyMatcherOptions in and respect applicable options
            if (positions.Count < LegCount)
            {
                return(Enumerable.Empty <OptionStrategyDefinitionMatch>());
            }

            var multiplier = int.MaxValue;

            // first check underlying lots has correct sign and sufficient magnitude
            var underlyingLotsSign = Math.Sign(UnderlyingLots);

            if (underlyingLotsSign != 0)
            {
                var underlyingPositionSign = Math.Sign(positions.UnderlyingQuantity);
                if (underlyingLotsSign != underlyingPositionSign ||
                    Math.Abs(positions.UnderlyingQuantity) < Math.Abs(UnderlyingLots))
                {
                    return(Enumerable.Empty <OptionStrategyDefinitionMatch>());
                }

                // set multiplier for underlying
                multiplier = positions.UnderlyingQuantity / UnderlyingLots;
            }

            // TODO : Consider add OptionStrategyLegDefinition for underlying for consistency purposes.
            //        Might want to enforce that it's always the first leg definition as well for easier slicing.
            return(Match(options,
                         ImmutableList <OptionStrategyLegDefinitionMatch> .Empty,
                         ImmutableList <OptionPosition> .Empty,
                         positions,
                         multiplier
                         ).Distinct());
        }
コード例 #4
0
 /// <summary>
 /// Initializes a new instance of the <see cref="OptionStrategyMatcher"/> class
 /// </summary>
 /// <param name="options">Specifies definitions and other options controlling the matcher</param>
 public OptionStrategyMatcher(OptionStrategyMatcherOptions options)
 {
     Options = options;
 }
コード例 #5
0
 /// <summary>
 /// Determines all possible matches for this definition using the provided <paramref name="positions"/>.
 /// This includes OVERLAPPING matches. It's up to the actual matcher to make decisions based on which
 /// matches to accept. This allows the matcher to prioritize matching certain positions over others.
 /// </summary>
 public IEnumerable <OptionStrategyDefinitionMatch> Match(OptionPositionCollection positions)
 {
     return(Match(OptionStrategyMatcherOptions.ForDefinitions(this), positions));
 }
コード例 #6
0
 /// <summary>
 /// Attempts to match the positions to this definition exactly once, by evaluating the enumerable and
 /// taking the first entry matched. If not match is found, then false is returned and <paramref name="match"/>
 /// will be null.
 /// </summary>
 public bool TryMatchOnce(OptionStrategyMatcherOptions options, OptionPositionCollection positions, out OptionStrategyDefinitionMatch match)
 {
     match = Match(options, positions).FirstOrDefault();
     return(match != null);
 }