/// <summary> /// Provides a convenience method for creating an option Symbol using SecurityIdentifier. /// </summary> /// <param name="underlyingSymbol">The underlying security symbol</param> /// <param name="market">The market the underlying resides in</param> /// <param name="style">The option style (American, European, ect..)</param> /// <param name="right">The option right (Put/Call)</param> /// <param name="strike">The option strike price</param> /// <param name="expiry">The option expiry date</param> /// <param name="alias">An alias to be used for the symbol cache. Required when /// adding the same security from diferent markets</param> /// <returns>A new Symbol object for the specified option contract</returns> public static Symbol CreateOption(Symbol underlyingSymbol, string market, OptionStyle style, OptionRight right, decimal strike, DateTime expiry, string alias = null) { var sid = SecurityIdentifier.GenerateOption(expiry, underlyingSymbol.ID, market, strike, right, style); if (expiry == SecurityIdentifier.DefaultDate) { alias = alias ?? $"?{underlyingSymbol.Value.LazyToUpper()}"; } else { var sym = underlyingSymbol.Value; if (sid.Symbol != underlyingSymbol.ID.Symbol) { // If we have changed the SID and it does not match the underlying, // we've mapped a future into another Symbol. We want to have a value // representing the mapped ticker, not of the underlying. // e.g. we want: // OG C3200...|GC18Z20 // NOT // GC C3200...|GC18Z20 sym = sid.Symbol; } if (sym.Length > 5) { sym += " "; } alias = alias ?? SymbolRepresentation.GenerateOptionTickerOSI(sym, sid.OptionRight, sid.StrikePrice, sid.Date); } return(new Symbol(sid, alias, underlyingSymbol)); }
/// <summary> /// Converts an Zerodha symbol to a Lean symbol instance /// </summary> /// <param name="brokerageSymbol">The Zerodha symbol</param> /// <param name="securityType">The security type</param> /// <param name="market">The market</param> /// <param name="expirationDate">Expiration date of the security(if applicable)</param> /// <param name="strike">The strike of the security (if applicable)</param> /// <param name="optionRight">The option right of the security (if applicable)</param> /// <returns>A new Lean Symbol instance</returns> public Symbol GetLeanSymbol(string brokerageSymbol, SecurityType securityType, string market, DateTime expirationDate = default(DateTime), decimal strike = 0, OptionRight optionRight = OptionRight.Call) { if (string.IsNullOrWhiteSpace(brokerageSymbol)) { throw new ArgumentException($"Invalid Zerodha symbol: {brokerageSymbol}"); } //if (!IsKnownBrokerageSymbol(brokerageSymbol)) // throw new ArgumentException($"Unknown Zerodha symbol: {brokerageSymbol}"); if (securityType == SecurityType.Forex || securityType == SecurityType.Cfd || securityType == SecurityType.Commodity || securityType == SecurityType.Crypto) { throw new ArgumentException($"Invalid security type: {securityType}"); } if (!Market.Encode(market).HasValue) { throw new ArgumentException($"Invalid market: {market}"); } switch (securityType) { case SecurityType.Option: OptionStyle optionStyle = OptionStyle.European; return(Symbol.CreateOption(brokerageSymbol.Replace(" ", "").Trim(), market, optionStyle, optionRight, strike, expirationDate)); case SecurityType.Future: return(Symbol.CreateFuture(brokerageSymbol.Replace(" ", "").Trim(), market, expirationDate)); default: return(Symbol.Create(brokerageSymbol.Replace(" ", "").Trim(), securityType, market)); } }
/// <summary> /// Provides a convenience method for creating an option Symbol. /// </summary> /// <param name="underlying">The underlying ticker</param> /// <param name="market">The market the underlying resides in</param> /// <param name="style">The option style (American, European, ect..)</param> /// <param name="right">The option right (Put/Call)</param> /// <param name="strike">The option strike price</param> /// <param name="expiry">The option expiry date</param> /// <param name="alias">An alias to be used for the symbol cache. Required when /// adding the same security from different markets</param> /// <param name="mapSymbol">Specifies if symbol should be mapped using map file provider</param> /// <returns>A new Symbol object for the specified option contract</returns> public static Symbol CreateOption(string underlying, string market, OptionStyle style, OptionRight right, decimal strike, DateTime expiry, string alias = null, bool mapSymbol = true) { var underlyingSid = SecurityIdentifier.GenerateEquity(underlying, market, mapSymbol); var underlyingSymbol = new Symbol(underlyingSid, underlying); return(CreateOption(underlyingSymbol, market, style, right, strike, expiry, alias)); }
/// <summary> /// Provides a convenience method for creating an option Symbol. /// </summary> /// <param name="underlying">The underlying ticker</param> /// <param name="market">The market the underlying resides in</param> /// <param name="style">The option style (American, European, ect..)</param> /// <param name="right">The option right (Put/Call)</param> /// <param name="strike">The option strike price</param> /// <param name="expiry">The option expiry date</param> /// <param name="alias">An alias to be used for the symbol cache. Required when /// adding the same security from diferent markets</param> /// <returns>A new Symbol object for the specified option contract</returns> public static Symbol CreateOption(string underlying, string market, OptionStyle style, OptionRight right, decimal strike, DateTime expiry, string alias = null) { var sid = SecurityIdentifier.GenerateOption(expiry, underlying, market, strike, right, style); alias = alias ?? string.Format("{0}_{1}_{2}_{3}", underlying, right.ToString()[0], strike.SmartRounding(), expiry.ToString("yyyyMMdd")); return(new Symbol(sid, alias)); }
/// <summary> /// Generates a new <see cref="SecurityIdentifier"/> for an option /// </summary> /// <param name="expiry">The date the option expires</param> /// <param name="underlying">The underlying security's symbol</param> /// <param name="market">The market</param> /// <param name="strike">The strike price</param> /// <param name="optionRight">The option type, call or put</param> /// <param name="optionStyle">The option style, American or European</param> /// <returns>A new <see cref="SecurityIdentifier"/> representing the specified option security</returns> public static SecurityIdentifier GenerateOption(DateTime expiry, SecurityIdentifier underlying, string market, decimal strike, OptionRight optionRight, OptionStyle optionStyle) { return(Generate(expiry, underlying.Symbol, SecurityType.Option, market, strike, optionRight, optionStyle, underlying)); }
/// <summary> /// Generates a new <see cref="SecurityIdentifier"/> for an option /// </summary> /// <param name="expiry">The date the option expires</param> /// <param name="underlying">The underlying security's symbol</param> /// <param name="market">The market</param> /// <param name="strike">The strike price</param> /// <param name="optionRight">The option type, call or put</param> /// <param name="optionStyle">The option style, American or European</param> /// <returns>A new <see cref="SecurityIdentifier"/> representing the specified option security</returns> public static SecurityIdentifier GenerateOption(DateTime expiry, SecurityIdentifier underlying, string market, decimal strike, OptionRight optionRight, OptionStyle optionStyle) { return(Generate(expiry, underlying.Symbol, QuantConnect.Symbol.GetOptionTypeFromUnderlying(underlying.SecurityType), market, strike, optionRight, optionStyle, underlying)); }
/// <summary> /// Provides a convenience method for creating an option Symbol. /// </summary> /// <param name="underlying">The underlying ticker</param> /// <param name="market">The market the underlying resides in</param> /// <param name="style">The option style (American, European, ect..)</param> /// <param name="right">The option right (Put/Call)</param> /// <param name="strike">The option strike price</param> /// <param name="expiry">The option expiry date</param> /// <param name="alias">An alias to be used for the symbol cache. Required when /// adding the same security from diferent markets</param> /// <returns>A new Symbol object for the specified option contract</returns> public static Symbol CreateOption(string underlying, string market, OptionStyle style, OptionRight right, decimal strike, DateTime expiry, string alias = null) { var sid = SecurityIdentifier.GenerateOption(expiry, underlying, market, strike, right, style); var sym = sid.Symbol; if (sym.Length > 5) { sym += " "; } // format spec: http://www.optionsclearing.com/components/docs/initiatives/symbology/symbology_initiative_v1_8.pdf alias = alias ?? string.Format("{0,-6}{1}{2}{3:00000000}", sym, sid.Date.ToString(DateFormat.SixCharacter), sid.OptionRight.ToString()[0], sid.StrikePrice * 1000m); return(new Symbol(sid, alias)); }
public void SymbolHashForOptionsBackwardsCompatibilityWholeNumber(OptionStyle style, OptionRight right, string expected) { var equity = Symbol.Create("AAPL", SecurityType.Equity, Market.USA); var option = Symbol.CreateOption( equity, Market.USA, style, right, 100m, new DateTime(2020, 5, 21)); Assert.AreEqual(expected, option.ID.ToString()); Assert.AreEqual(100m, option.ID.StrikePrice); }
public void SymbolHashForOptionsBackwardsCompatibilityFractionalNumber(OptionStyle style, OptionRight right, string expected) { var equity = Symbol.Create("AAPL", SecurityType.Equity, Market.USA); var option = Symbol.CreateOption( equity, Market.USA, style, right, 0.01m, // strike decimal precision is limited to 4 decimal places only new DateTime(2020, 5, 21)); Assert.AreEqual(expected, option.ID.ToString()); Assert.AreEqual(0.01m, option.ID.StrikePrice); }
/// <summary> /// Generic generate method. This method should be used carefully as some parameters are not required and /// some parameters mean different things for different security types /// </summary> private static SecurityIdentifier Generate(DateTime date, string symbol, SecurityType securityType, string market, decimal strike = 0, OptionRight optionRight = 0, OptionStyle optionStyle = 0, SecurityIdentifier?underlying = null, bool forceSymbolToUpper = true) { if ((ulong)securityType >= SecurityTypeWidth || securityType < 0) { throw new ArgumentOutOfRangeException(nameof(securityType), "securityType must be between 0 and 99"); } if ((int)optionRight > 1 || optionRight < 0) { throw new ArgumentOutOfRangeException(nameof(optionRight), "optionType must be either 0 or 1"); } // normalize input strings market = market.ToLowerInvariant(); symbol = forceSymbolToUpper ? symbol.LazyToUpper() : symbol; var marketIdentifier = QuantConnect.Market.Encode(market); if (!marketIdentifier.HasValue) { throw new ArgumentOutOfRangeException(nameof(market), "The specified market wasn't found in the markets lookup. " + $"Requested: {market}. You can add markets by calling QuantConnect.Market.AddMarket(string,ushort)" ); } var days = (ulong)date.ToOADate() * DaysOffset; var marketCode = (ulong)marketIdentifier * MarketOffset; ulong strikeScale; var strk = NormalizeStrike(strike, out strikeScale) * StrikeOffset; strikeScale *= StrikeScaleOffset; var style = (ulong)optionStyle * OptionStyleOffset; var putcall = (ulong)optionRight * PutCallOffset; var otherData = putcall + days + style + strk + strikeScale + marketCode + (ulong)securityType; return(new SecurityIdentifier(symbol, otherData, underlying ?? Empty)); }
public OptionData(OptionType optType, OptionStyle optStyle, String baseActive, DateTime countDate, DateTime dateExpiration, float strikePrice, float contractHigh, float contractLow, float contractClose, int openInterest, int volume) { Type = optType; Style = optStyle; BaseActive = baseActive; DatePublished = countDate; DateExpiration = dateExpiration; StrikePrice = strikePrice; ContractHigh = contractHigh; ContractLow = contractLow; ContractClose = contractClose; OpenInterest = openInterest; Volume = volume; }
private News MakeOptionLevelNews(DateTime curDate, string curSymbol, ExpirationMonth expMonth, OptionStyle optStyle, OptionType optType, decimal strike, int volume, int OI, decimal closeRange, decimal openRange, decimal high, decimal low, decimal delta, decimal settPrice) { //[#fmt]#&newstype=option#&type=Call#&style=American#&baseactive=EURUSD#& //publishdate=09.03.2011 02:34:00#&dateexpiration=11.06.2011#&strikeprice=1.4550#& //high=0.0140#&low=0.0090#&close=0.0110#&oi=948#&volume=0 var newsBody = string.Format(CultureProvider.Common, "[#fmt]#&newstype=option#&type={0}#&style={1}#&baseactive={2}#&" + "publishdate={3:dd.MM.yyyy HH:mm:ss}#&dateexpiration={4:dd.MM.yyyy}#&strikeprice={5}#&" + "high={6}#&low={7}#&close={8}#&oi={9}#&volume={10}", optType, optStyle, curSymbol, curDate, new DateTime(expMonth.Year, expMonth.Month, 11), strike, high, low, closeRange, OI, volume); return(new News(newsChannelId, curDate, titleNewsOption, newsBody)); }
/// <summary> /// Generic generate method. This method should be used carefully as some parameters are not required and /// some parameters mean different things for different security types /// </summary> private static SecurityIdentifier Generate(DateTime date, string symbol, SecurityType securityType, string market, decimal strike = 0, OptionRight optionRight = 0, OptionStyle optionStyle = 0) { if ((ulong)securityType >= SecurityTypeWidth || securityType < 0) { throw new ArgumentOutOfRangeException("securityType", "securityType must be between 0 and 99"); } if ((int)optionRight > 1 || optionRight < 0) { throw new ArgumentOutOfRangeException("optionRight", "optionType must be either 0 or 1"); } // normalize input strings market = market.ToLower(); symbol = symbol.ToUpper(); var marketIdentifier = QuantConnect.Market.Encode(market); if (!marketIdentifier.HasValue) { throw new ArgumentOutOfRangeException("market", string.Format("The specified market wasn't found in the markets lookup. Requested: {0}. " + "You can add markets by calling QuantConnect.Market.AddMarket(string,ushort)", market)); } var days = ((ulong)date.ToOADate()) * DaysOffset; var marketCode = (ulong)marketIdentifier * MarketOffset; ulong strikeScale; var strk = NormalizeStrike(strike, out strikeScale) * StrikeOffset; strikeScale *= StrikeScaleOffset; var style = ((ulong)optionStyle) * OptionStyleOffset; var putcall = (ulong)(optionRight) * PutCallOffset; var otherData = putcall + days + style + strk + strikeScale + marketCode + (ulong)securityType; return(new SecurityIdentifier(symbol, otherData)); }
/// <summary> /// Creates a new option. /// </summary> /// <param name="options">Cli arguments that use this option.</param> /// <param name="description">Description of this option.</param> /// <param name="func">Action to perform when this option is specified.</param> /// <param name="style">Style of option to use.</param> /// <param name="optionalArgs">If this is true, arguments will be treated as non compulsary ones.</param> public Option(string options, string description, Action <string> func, OptionStyle style, bool optionalArgs = false) { Action = func; var spl = options.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); Arguments = spl.Select(s => OptionsPrefixes[(int)style + ((s.Length == 1) ? 0 : 1)] + s).ToArray(); var opts = new List <string>(); foreach (Match match in Regex.Matches(description, "{[^}]*}")) { var val = match.Value.Substring(1, match.Length - 2); opts.Add(val.ToUpper()); description = description.Substring(0, match.Index) + val + description.Substring(match.Index + match.Length); } Description = description; Options = opts.ToArray(); ExpectsArguments = opts.Count > 0 && !optionalArgs; }
/// <summary> /// Provides a convenience method for creating an option Symbol using SecurityIdentifier. /// </summary> /// <param name="underlyingSymbol">The underlying security symbol</param> /// <param name="market">The market the underlying resides in</param> /// <param name="style">The option style (American, European, ect..)</param> /// <param name="right">The option right (Put/Call)</param> /// <param name="strike">The option strike price</param> /// <param name="expiry">The option expiry date</param> /// <param name="alias">An alias to be used for the symbol cache. Required when /// adding the same security from diferent markets</param> /// <returns>A new Symbol object for the specified option contract</returns> public static Symbol CreateOption(Symbol underlyingSymbol, string market, OptionStyle style, OptionRight right, decimal strike, DateTime expiry, string alias = null) { var sid = SecurityIdentifier.GenerateOption(expiry, underlyingSymbol.ID, market, strike, right, style); if (expiry == SecurityIdentifier.DefaultDate) { alias = alias ?? "?" + underlyingSymbol.Value.ToUpper(); } else { var sym = underlyingSymbol.Value; if (sym.Length > 5) { sym += " "; } alias = alias ?? SymbolRepresentation.GenerateOptionTickerOSI(sym, sid.OptionRight, sid.StrikePrice, sid.Date); } return(new Symbol(sid, alias, underlyingSymbol)); }
/// <summary> /// Gets a formatted description of the contract class defined by <typeparamref name="T"/> /// </summary> /// <typeparam name="T">The contract class type</typeparam> /// <param name="executableName">The name of the executable; if not given, defaults to Process.GetCurrentProcess().MainModule.FileName</param> /// <param name="lineLength">The length at which to start wrapping lines</param> /// <param name="optionStyle">The command line syntax style, default is <see cref="OptionStyle.Unix"/></param> public static string GetDescription <T>(string executableName = null, int lineLength = 100, OptionStyle optionStyle = OptionStyle.Unix) { executableName = executableName ?? Path.GetFileName(Process.GetCurrentProcess().MainModule.FileName); var properties = GetProperties <T>(); var descriptionBuilder = new StringBuilder(properties.Count() * 50); const int aliasIndent = 1; var aliasPrefix = optionStyle == OptionStyle.Unix ? "-" : "/"; var prefix = optionStyle == OptionStyle.Unix ? "--" : "/"; var valuePrefix = optionStyle == OptionStyle.Unix ? "=" : ":"; //first print the command summary descriptionBuilder.Append(executableName); foreach (var property in properties.Where(p => !p.IsValueProperty).OrderByDescending(p => p.Required).ThenBy(p => p.Name)) { var format = property.Required ? " {0}{1}{2}{3}" : " [{0}{1}{2}{3}]"; descriptionBuilder.Append(string.Format(format, prefix, property.Name, property.ValueName != null ? valuePrefix : "", property.ValueName)); } var valueProperty = properties.FirstOrDefault(p => p.IsValueProperty); if (valueProperty != null) { descriptionBuilder.Append(" " + valueProperty.ValueName ?? valueProperty.Name); } var summaryLines = WordWrap(descriptionBuilder.ToString(), lineLength); descriptionBuilder.Clear(); descriptionBuilder.AppendLine(); descriptionBuilder.AppendLine("USAGE"); descriptionBuilder.Append(string.Join(Environment.NewLine, summaryLines)); descriptionBuilder.AppendLine(); descriptionBuilder.AppendLine(); var descriptionStartColumn = properties.Max(property => { if (property.IsValueProperty) { return(property.ValueName != null ? property.ValueName.Length : property.Name.Length); } var length = property.Name.Length + prefix.Length; if (property.ValueName != null) { length += 1 + property.ValueName.Length; //+1 for "=" or ":" } if (property.IsComplexFlag) { length += 5; //appends [+|-] } if (property.Aliases.Any()) { length = Math.Max(length, property.Aliases.Max(alias => alias.Length + aliasPrefix.Length + aliasIndent)); } return(length); }) + 1; //+1 for padding var adjustedLineLength = lineLength - descriptionStartColumn; //first render the value property stuff if (valueProperty != null) { var name = valueProperty.ValueName ?? valueProperty.Name; descriptionBuilder.AppendLine("ARGUMENTS"); descriptionBuilder.Append(name); descriptionBuilder.Append(new string(' ', descriptionStartColumn - name.Length)); var lines = WordWrap(valueProperty.Description, adjustedLineLength); if (lines.Count > 0) { var spaceLength = 0; foreach (var line in lines) { descriptionBuilder.AppendLine(new string(' ', spaceLength) + line); spaceLength = descriptionStartColumn; } } else { descriptionBuilder.AppendLine(); } descriptionBuilder.AppendLine(); } descriptionBuilder.AppendLine("OPTIONS"); foreach (var property in properties.Where(p => !p.IsValueProperty).OrderBy(p => p.Name)) { descriptionBuilder.Append(prefix + property.Name); var indent = property.Name.Length + prefix.Length; if (property.IsComplexFlag) { descriptionBuilder.Append("[+|-]"); indent += 5; } if (property.ValueName != null) { descriptionBuilder.Append(valuePrefix + property.ValueName); indent += valuePrefix.Length + property.ValueName.Length; } descriptionBuilder.Append(new string(' ', descriptionStartColumn - indent)); var lines = WordWrap(property.Description, adjustedLineLength); var aliases = property.Aliases.OrderBy(alias => alias).ToList(); var i = 1; if (lines.Count > 0) { var spaceLength = 0; for (i = 0; i < lines.Count; i++) { if (i > 0) { var alias = aliases.ElementAtOrDefault(i - 1); if (alias != null) { descriptionBuilder.Append(new string(' ', aliasIndent) + aliasPrefix + alias); spaceLength = spaceLength - (aliasIndent + alias.Length + aliasPrefix.Length); } } descriptionBuilder.Append(new string(' ', spaceLength)); descriptionBuilder.AppendLine(lines[i]); spaceLength = descriptionStartColumn; } } else { descriptionBuilder.AppendLine(); } for (i = i - 1; i < aliases.Count; i++) { descriptionBuilder.AppendLine(new string(' ', aliasIndent) + aliasPrefix + aliases[i]); } } return(descriptionBuilder.ToString()); }
/// <summary> /// Generic generate method. This method should be used carefully as some parameters are not required and /// some parameters mean different things for different security types /// </summary> private static SecurityIdentifier Generate(DateTime date, string symbol, SecurityType securityType, string market, decimal strike = 0, OptionRight optionRight = 0, OptionStyle optionStyle = 0, SecurityIdentifier underlying = null, bool forceSymbolToUpper = true) { if ((ulong)securityType >= SecurityTypeWidth || securityType < 0) { throw new ArgumentOutOfRangeException(nameof(securityType), "securityType must be between 0 and 99"); } if ((int)optionRight > 1 || optionRight < 0) { throw new ArgumentOutOfRangeException(nameof(optionRight), "optionType must be either 0 or 1"); } // normalize input strings market = market.ToLowerInvariant(); symbol = forceSymbolToUpper ? symbol.LazyToUpper() : symbol; if (securityType == SecurityType.FutureOption) { // Futures options tickers might not match, so we need // to map the provided future Symbol to the actual future option Symbol. symbol = FuturesOptionsSymbolMappings.Map(symbol); } var marketIdentifier = QuantConnect.Market.Encode(market); if (!marketIdentifier.HasValue) { throw new ArgumentOutOfRangeException(nameof(market), "The specified market wasn't found in the markets lookup. " + $"Requested: {market}. You can add markets by calling QuantConnect.Market.AddMarket(string,ushort)" ); } var days = (ulong)date.ToOADate() * DaysOffset; var marketCode = (ulong)marketIdentifier * MarketOffset; ulong strikeScale; var strk = NormalizeStrike(strike, out strikeScale) * StrikeOffset; strikeScale *= StrikeScaleOffset; var style = (ulong)optionStyle * OptionStyleOffset; var putcall = (ulong)optionRight * PutCallOffset; var otherData = putcall + days + style + strk + strikeScale + marketCode + (ulong)securityType; var result = new SecurityIdentifier(symbol, otherData, underlying ?? Empty); // we already have these so lets set them switch (securityType) { case SecurityType.Base: case SecurityType.Equity: case SecurityType.Future: result._date = date; break; case SecurityType.Option: case SecurityType.FutureOption: result._date = date; result._strikePrice = strike; result._optionRight = optionRight; result._optionStyle = optionStyle; break; } return(result); }
public void OptionUserFriendlyDeserialization(string jsonValue, SecurityType type, string underlying, OptionRight optionRight, OptionStyle optionStyle, int expirationYear) { var symbol = JsonConvert.DeserializeObject <Symbol>(jsonValue); Assert.IsNotNull(symbol); Assert.AreEqual(type, symbol.SecurityType); Assert.AreEqual(underlying, symbol.ID.Underlying.Symbol); Assert.AreEqual(optionRight, symbol.ID.OptionRight); Assert.AreEqual(optionStyle, symbol.ID.OptionStyle); Assert.AreEqual(expirationYear, symbol.ID.Date.Year); }
private News MakeOptionLevelNews(DateTime curDate, string curSymbol, ExpirationMonth expMonth, OptionStyle optStyle, OptionType optType, decimal strike, int volume, int OI, decimal closeRange, decimal openRange, decimal high, decimal low, decimal delta, decimal settPrice) { //[#fmt]#&newstype=option#&type=Call#&style=American#&baseactive=EURUSD#& //publishdate=09.03.2011 02:34:00#&dateexpiration=11.06.2011#&strikeprice=1.4550#& //high=0.0140#&low=0.0090#&close=0.0110#&oi=948#&volume=0 var newsBody = string.Format(CultureProvider.Common, "[#fmt]#&newstype=option#&type={0}#&style={1}#&baseactive={2}#&" + "publishdate={3:dd.MM.yyyy HH:mm:ss}#&dateexpiration={4:dd.MM.yyyy}#&strikeprice={5}#&" + "high={6}#&low={7}#&close={8}#&oi={9}#&volume={10}", optType, optStyle, curSymbol, curDate, new DateTime(expMonth.Year, expMonth.Month, 11), strike, high, low, closeRange, OI, volume); return new News(newsChannelId, curDate, titleNewsOption, newsBody); }
/// <summary> /// Parses command line options, injecting values into the given instance of the option contract /// </summary> /// <typeparam name="T">The type of the option contract</typeparam> /// <param name="args">The command line arguments to parse</param> /// <param name="contract">An instance of the option contract</param> /// <param name="optionStyle">The command line syntax style, default is <see cref="OptionStyle.Unix"/></param> /// <seealso cref="Parse{T}(string[],OptionStyle)"/> public static IOptionParseResult <T> Parse <T>(string[] args, T contract, OptionStyle optionStyle = OptionStyle.Unix) { var properties = GetProperties <T>(); var nonOptionValues = new List <string>(); var errors = new List <ParsingError>(); for (var i = 0; i < args.Length; i++) { var arg = args[i]; var name = (optionStyle == OptionStyle.Windows ? windowsRegex : unixRegex).Match(arg); if (!name.Success) { nonOptionValues.Add(arg); continue; } var optionName = name.Groups[1].Value; string value = null; if (optionName.EndsWith("+") || optionName.EndsWith("-")) { //handle on/off switches, e.g. /debug+ or /debug- value = optionName.Last() == '+' ? bool.TrueString : bool.FalseString; optionName = optionName.Substring(0, optionName.Length - 1); } var property = properties.FirstOrDefault(p => p.NameMatches(optionName)); if (property == null) { //no contract for this option, so it's a value nonOptionValues.Add(arg); continue; } if (value != null && property.IsFlag) { //this won't throw because the only possible values are bool.TrueString and bool.FalseString property.SetValue(contract, value); if (property.IsComplexFlag) { //complex flags are options with boolean switches, but also take values //e.g. /warnaserror+:1400,1456,1680 property = new OptionProperty(property.ComplexValueProperty); } else { continue; } } if (arg.Length > name.Length) { //the value is given after = or : value = arg.Substring(name.Length + 1); } else if (property.IsFlag && !property.IsComplexFlag) { value = bool.TrueString; } else if (i + 1 < args.Length) { //value is the next arg value = args[++i]; } try { property.SetValue(contract, value); } catch (Exception e) { errors.Add(new ParsingError { Argument = arg, ThrownException = e }); } } //inject values into ValueProperty property, if given var valueProperty = properties.FirstOrDefault(p => p.IsValueProperty); if (valueProperty != null) { valueProperty.SetNonOptionValues(contract, nonOptionValues.ToArray()); } return(new OptionParseResult <T>(contract, errors)); }
public void ThrowsIfOptionStyleIsNotSupportedByQLPricingModel(string qlModelName, OptionStyle optionStyle, bool shouldThrow) { const decimal underlyingPrice = 200m; const decimal underlyingVol = 0.15m; var tz = TimeZones.NewYork; var evaluationDate = new DateTime(2015, 2, 19); var spy = Symbols.SPY; var SPY_C_192_Feb19_2016E = GetOptionSymbol(spy, optionStyle, OptionRight.Call); var SPY_P_192_Feb19_2016E = GetOptionSymbol(spy, optionStyle, OptionRight.Put); // setting up underlying var equity = GetEquity(spy, underlyingPrice, underlyingVol, tz); // setting up European style call option var contractCall = GetOptionContract(SPY_C_192_Feb19_2016E, spy, evaluationDate); var optionCall = GetOption(SPY_C_192_Feb19_2016E, equity, tz); // setting up European style put option var contractPut = GetOptionContract(SPY_P_192_Feb19_2016E, spy, evaluationDate); var optionPut = GetOption(SPY_P_192_Feb19_2016E, equity, tz); // running evaluation var priceModel = (IOptionPriceModel)typeof(OptionPriceModels).GetMethod(qlModelName).Invoke(null, new object[] {}); TestDelegate call = () => priceModel.Evaluate(optionCall, null, contractCall); TestDelegate put = () => priceModel.Evaluate(optionPut, null, contractPut); if (shouldThrow) { Assert.Throws <ArgumentException>(call); Assert.Throws <ArgumentException>(put); } else { Assert.DoesNotThrow(call); Assert.DoesNotThrow(put); var results = priceModel.Evaluate(optionCall, null, contractCall); var greeks = results.Greeks; Assert.That(greeks.Delta, Is.InRange(0, 1m)); Assert.Less(greeks.Theta, 0); Assert.Greater(greeks.Rho, 0m); Assert.Greater(greeks.Vega, 0m); results = priceModel.Evaluate(optionPut, null, contractPut); greeks = results.Greeks; Assert.That(greeks.Delta, Is.InRange(-1m, 0)); Assert.Less(greeks.Theta, 0); Assert.Less(greeks.Rho, 0m); Assert.Greater(greeks.Vega, 0m); } }
private Symbol GetOptionSymbol(Symbol underlying, OptionStyle optionStyle, OptionRight optionRight) { return(Symbol.CreateOption(underlying.Value, Market.USA, optionStyle, optionRight, 192m, new DateTime(2016, 02, 19))); }
/// <summary> /// Provides a convenience method for creating an option Symbol using SecurityIdentifier. /// </summary> /// <param name="underlyingSymbol">The underlying security symbol</param> /// <param name="market">The market the underlying resides in</param> /// <param name="style">The option style (American, European, ect..)</param> /// <param name="right">The option right (Put/Call)</param> /// <param name="strike">The option strike price</param> /// <param name="expiry">The option expiry date</param> /// <param name="alias">An alias to be used for the symbol cache. Required when /// adding the same security from diferent markets</param> /// <returns>A new Symbol object for the specified option contract</returns> public static Symbol CreateOption(Symbol underlyingSymbol, string market, OptionStyle style, OptionRight right, decimal strike, DateTime expiry, string alias = null) { var sid = SecurityIdentifier.GenerateOption(expiry, underlyingSymbol.ID, market, strike, right, style); return(new Symbol(sid, alias ?? GetAlias(sid, underlyingSymbol), underlyingSymbol)); }
/// <summary> /// Parses command line options, injecting values into a new instance of the option contract /// defined in <typeparamref name="T"/> /// </summary> /// <typeparam name="T">The type of the option contract</typeparam> /// <param name="args">The command line arguments to parse</param> /// <param name="optionStyle">The command line syntax style, default is <see cref="OptionStyle.Unix"/></param> /// <seealso cref="Parse{T}(string[],T,OptionStyle)"/> public static IOptionParseResult <T> Parse <T>(string[] args, OptionStyle optionStyle = OptionStyle.Unix) where T : new() { return(Parse(args, new T(), optionStyle)); }