// Prices European option using Monte Carlo simulation
 public double PriceEuropeanOption(double startingAssetValue, double interestRate, OptionType optionType, double strike,
     double volatility, double timeStep, int numberOfTimeSteps)
 {
     int numberOfSimulations = 250;
     object syncLock = new object();
     double sumOfFutureValuesOfOption = 0.0;
     Parallel.For(0, numberOfSimulations, simulationNumber =>
         {
             double currentAssetValue = startingAssetValue, futureValueOfOption = 0.0;
             // each simulation
             for (int i = 0; i < numberOfTimeSteps; i++)
             {
                 currentAssetValue = SimulateNextAssetValue(currentAssetValue, interestRate, timeStep, volatility);
             }
             futureValueOfOption = Math.Max((int)optionType * (currentAssetValue - strike), 0);
             // lock to ensure that each addition is atomic.
             // TODO: this is a bottleneck as locking not only
             //      makes this loop linear but slows it down even more due to locking overhead.
             //      *Potential Race Condition too!*
             lock (syncLock)
             {
                 sumOfFutureValuesOfOption += futureValueOfOption;
             }
         });
     double averageFutureValueOfOption = sumOfFutureValuesOfOption / numberOfSimulations;
     // compute present value of the average future value. here timeStep*numberOfTimeSteps gives total time to expiry
     double optionValue = Math.Exp(-interestRate * timeStep * numberOfTimeSteps) * averageFutureValueOfOption;
     return optionValue;
 }

        internal Option(string displayName, int? addressId, AddressType? addressType, string postcode, OptionType optionType, Model.Link[] links)
        {
            if (string.IsNullOrWhiteSpace(displayName)) throw new ArgumentNullException("displayName");
            if (links == null) throw new ArgumentNullException("links");

            DisplayName = displayName;
            AddressId = addressId;
            AddressType = addressType;
            Postcode = postcode;
            OptionType = optionType;

            var newLinks = new List<Model.Link>();

            foreach (Model.Link link in links)
            {
                Model.Link newLink;

                switch (link.Rel)
                {
                    case "next":
                        newLink = new Link(link.Rel, link.Href);
                        break;
                    default:
                        newLink = link;
                        break;
                }

                newLinks.Add(newLink);
            }

            Links = newLinks.ToArray();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="abc"></param>
        /// <param name="method"></param>
        /// <param name="argument"></param>
        public AVM2Argument( AbcFile abc, UInt32 method, UInt32 argument )
        {
            _ArgumentType = abc.ConstantPool.Multinames[ ( int )abc.Methods[ ( int )method ].ParamType[ ( int )argument ] ].ToString( abc );

            if ( abc.Methods[ ( int )method ].FlagHasParamNames )
            {
                _ArgumentName = abc.ConstantPool.Strings[ ( int )abc.Methods[ ( int )method ].ParamNames[ ( int )argument ] ];
            }
            else
            {
                _ArgumentName = "(no param name)";
            }

            if ( ( abc.Methods[ ( int )method ].FlagHasOptional ) && ( argument < abc.Methods[ ( int )method ].Option.Count ) )
            {
                _IsOptional = true;
                _OptionalType = abc.Methods[ ( int )method ].Option[ ( int )argument ].OptionType;
                _OptionalTypeName = abc.Methods[ ( int )method ].Option[ ( int )argument ].OptionTypeName;
                _OptionalValue = abc.Methods[ ( int )method ].Option[ ( int )argument ].GetValue( abc );
            }
            else
            {
                _IsOptional = false;
                _OptionalType = OptionType.TotallyInvalid;
                _OptionalValue = null;
            }
        }

 public DynamicOption(string name, OptionType expectedType, bool isRequired, IEnumerable<object> permittedValues)
 {
     Name = name;
     ExpectedType = expectedType;
     IsRequired = isRequired;
     PermittedValues = permittedValues;
 }

 public Option(OptionType Type, bool OnlineOnly, string Name, Uri ImageUrl)
 {
     this.Type = Type;
     this.OnlineOnly = OnlineOnly;
     this.Name = Name;
     this.ImageUrl = ImageUrl;
 }

 private FxOption(OptionType type, double strike, double spot, double dividend, double riskfreerate,
     double ttm, double vol, Date date, double crossriskfreerate)
     : base(type, strike, spot, dividend, riskfreerate, ttm, vol, date)
 {
     _crossriskfreerate = crossriskfreerate;
     _npv = 0.0;
 }

        public OptionItem(string key, string description, string defaultvalue, OptionType type = OptionType.String, bool required = false, Func<string, bool> validator = null)
        {
            this.Key =  key;
            this.Description = description;
            this.DefaultValue = defaultvalue;
            this.Required = required;
            this.Type = type;
            if (validator != null)
                this.Validator = validator;
            else
            {
                if (this.Type == OptionType.Boolean)
                    this.Validator = (x) => {
                        bool b;
                        return string.IsNullOrEmpty(x) || bool.TryParse(x, out b);
                    };
                else if (this.Type == OptionType.Integer)
                    this.Validator = (x) => {
                        int i;
                        return int.TryParse(x, out i);
                    };
                else
                    this.Validator = null;

            }
        }

        public HttpResponseMessage add(OptionType post, Int32 languageId = 0)
        {
            // Check for errors
            if (post == null)
            {
                return Request.CreateResponse<string>(HttpStatusCode.BadRequest, "The post is null");
            }
            else if (Language.MasterPostExists(languageId) == false)
            {
                return Request.CreateResponse<string>(HttpStatusCode.BadRequest, "The language does not exist");
            }

            // Make sure that the data is valid
            post.title = AnnytabDataValidation.TruncateString(post.title, 100);
            post.google_name = AnnytabDataValidation.TruncateString(post.google_name, 50);

            // Add the post
            Int64 insertId = OptionType.AddMasterPost(post);
            post.id = Convert.ToInt32(insertId);
            OptionType.AddLanguagePost(post, languageId);

            // Return the success response
            return Request.CreateResponse<string>(HttpStatusCode.OK, "The post has been added");

        } // End of the add method

        public HttpResponseMessage update(OptionType post, Int32 languageId = 0)
        {

            // Check for errors
            if (post == null)
            {
                return Request.CreateResponse<string>(HttpStatusCode.BadRequest, "The post is null");
            }
            else if (Language.MasterPostExists(languageId) == false)
            {
                return Request.CreateResponse<string>(HttpStatusCode.BadRequest, "The language does not exist");
            }

            // Make sure that the data is valid
            post.title = AnnytabDataValidation.TruncateString(post.title, 100);
            post.google_name = AnnytabDataValidation.TruncateString(post.google_name, 50);

            // Get the saved post
            OptionType savedPost = OptionType.GetOneById(post.id, languageId);

            // Check if the post exists
            if (savedPost == null)
            {
                return Request.CreateResponse<string>(HttpStatusCode.BadRequest, "The record does not exist");
            }

            // Update the post
            OptionType.UpdateMasterPost(post);
            OptionType.UpdateLanguagePost(post, languageId);

            // Return the success response
            return Request.CreateResponse<string>(HttpStatusCode.OK, "The update was successful");

        } // End of the update method

 public ProfileOption(MenuType menuType, string id, OptionType type, string value)
 {
     MenuType = menuType;
     Id = id;
     Type = type;
     Value = value;
 }

    public void loadCharSkill(OptionType opt)
    {
        _count = 0;
        removeItens();

        switch (opt)
        {
            case OptionType.Special:

                for (int i = 0; i < 4; i++)
                {
                    if (GlobalCharacter.player.specials[i] != null)
                    {
                        addSkill(GlobalCharacter.player.specials[i]);
                    }
                }

                break;
            case OptionType.Item:

                for (int i = 0; i < 4; i++)
                {
                    if (GlobalCharacter.player.itens[i] != null)
                    {
                        addItem(GlobalCharacter.player.itens[i]);
                    }
                }

                break;
        }
        this.guiTexture.pixelInset = new Rect(135, 60, 220, _count * 40);
        _fight.currentAction = opt;
    }

        public static double Price(OptionType optionType, double Fwd, double K,
            double T, double r, double σ, PriceType priceType = PriceType.Price)
        {
            double std = σ * Math.Sqrt(T);
            double DF = Math.Exp(-r * T);

            double d1 = (Math.Log(Fwd / K) + 0.5*std*std ) / std;
            double d2 = d1 - std;

            switch(priceType)
            {
                case PriceType.Price:
                    if (optionType == OptionType.Call)
                        return DF * ( Fwd * N(d1) - K *  N(d2) );
                    else if (optionType == OptionType.Put)
                        return DF * ( K * N(-d2) - Fwd * N(-d1) );
                    break;
                case PriceType.Δ:
                    return DF * Fwd * N(d1);
                case PriceType.Vega:
                    return DF * Fwd * Math.Sqrt(T) * Nprime(d1);
                case PriceType.Γ:
                    return 1 / ( DF * Fwd * std ) * Nprime(d1);
            }

            throw new Exception();
        }

        public AbstractOption(OptionType key)
        {
            this.ID = Guid.NewGuid();
            this.Key = key;

            Name = MultiLanguageTextProxy.GetText("OptionType_" + key.ToString() + "_Name", key.ToString());
            Description = MultiLanguageTextProxy.GetText("OptionType_" + key.ToString() + "_Description", key.ToString());                
        }

 public OptionInfo(string name, string underlying, OptionType type, double strike, DateTime expiryDate)
 {
     this.Name = name;
     this.Underlying = underlying;
     this.Type = type;
     this.Strike = strike;
     this.ExpiryDate = expiryDate;
 }

 public OptionSpec(string name, OptionType valueType, string helpText, bool isRequired, string valueText = null)
 {
    Name = name;
    ValueType = valueType;
    HelpText = helpText;
    IsRequired = isRequired;
    ValueText = valueText;
 }

        public Option PriceWithMarketData(OptionType optionType, string underlyingName, DateTime maturity, double strike)
        {
            double spot = this.MarketDataService.GetSpot(underlyingName);
            double volatility = this.MarketDataService.GetHistoricalVolatility(underlyingName, this.DateService.Now, (int)maturity.Subtract(this.DateService.Now).TotalDays);
            double interestRate = this.MarketDataService.GetInterestRate();

            return this.Price(optionType, underlyingName, maturity, strike, spot, volatility, interestRate);
        }

 public AnalyzeOptionInfo(string fullName, 
     string description,
     OptionType optionType)
 {
     FullName = fullName;
     Description = description;
     OptionType = optionType;
 }

 public EquityOptionStaticData(OptionType type, double strike, double spot, double volatility, double riskFreeRate, double timeToMaturity)
 {
     this.Type = type;
     this.Strike = strike;
     this.Spot = spot;
     this.Volatility = volatility;
     this.RiskFreeRate = riskFreeRate;
     this.TimeToMaturity = timeToMaturity;
 }

 protected Option(IUnderlying underlying, DateTime expirationDate, OptionType callOrPut, decimal strike,
     decimal premium)
 {
     Underlying = underlying;
     ExpirationDate = expirationDate;
     CallOrPut = callOrPut;
     Strike = strike;
     Premium = premium;
 }

 public Option()
 {
     _price = 50.0;
     _strike = 50.0;
     _rate = 0.06;
     _dividend = 0.0;
     _timeToMaturity = 1;
     _type = OptionType.Call;
     _exercise = OptionExercise.European;
 }