void BarrierOption::arguments::validate() const {
        OneAssetOption::arguments::validate();

        switch (barrierType) {
          case Barrier::DownIn:
          case Barrier::UpIn:
          case Barrier::DownOut:
          case Barrier::UpOut:
            break;
          default:
            QL_FAIL("unknown type");
        }

        QL_REQUIRE(barrier != Null<Real>(), "no barrier given");
        QL_REQUIRE(rebate != Null<Real>(), "no rebate given");
    }

 // gets a price that can include an arbitrary number of basis curves
 inline Real CommodityCurve::price(
             const Date& d,
             const boost::shared_ptr<ExchangeContracts>& exchangeContracts,
             Integer nearbyOffset) const {
     Date date = nearbyOffset > 0 ?
         underlyingPriceDate(d, exchangeContracts, nearbyOffset) : d;
     Time t = timeFromReference(date);
     Real priceValue = 0;
     try {
         priceValue = priceImpl(t);
     } catch (const std::exception& e) {
         QL_FAIL("error retrieving price for curve [" << name() << "]: "
                 << e.what());
     }
     return priceValue + basisOfPriceImpl(t);
 }

	std::vector<Real> cap_floor(Date evaluationDate,
		CapFloor::Type type,
		Real strike,
		Real nominal,
		Schedule schedule,
		Natural fixingDays,
		BusinessDayConvention convention,
		boost::shared_ptr<IborIndex> index,
		boost::shared_ptr<YieldTermStructure> termStructure,
		Volatility volatility) {

			Date todaysDate = evaluationDate;
			Settings::instance().evaluationDate() = todaysDate;
			std::vector<Real> nominals = std::vector<Real>(1, nominal);		

			/*Make Leg*/
			Leg leg = IborLeg(schedule, index)
				.withNotionals(nominals)
				.withPaymentDayCounter(index->dayCounter())
				.withPaymentAdjustment(convention)
				.withFixingDays(fixingDays);

			/*Make Engine*/
			Handle<Quote> vol(boost::shared_ptr<Quote>(new SimpleQuote(volatility)));
			boost::shared_ptr<PricingEngine> engine = 
				boost::shared_ptr<PricingEngine>(new BlackCapFloorEngine(Handle<YieldTermStructure>(termStructure), vol));

			/*Pricing*/
			boost::shared_ptr<CapFloor> testProduct;
			switch (type) {
			case CapFloor::Cap:
				testProduct = boost::shared_ptr<CapFloor>(new Cap(leg, std::vector<Rate>(1, strike)));
				break;
			case CapFloor::Floor:
				testProduct = boost::shared_ptr<CapFloor>(new Floor(leg, std::vector<Rate>(1, strike)));
				break;
			default:
				QL_FAIL("unknown cap/floor type");
			}

			testProduct->setPricingEngine(engine);

			std::vector<Real> rst;
			rst.push_back(testProduct->NPV());		
			return rst;

	}

    Date Date::advance(const Date& date, Integer n, TimeUnit units) {
        switch (units) {
          case Days:
            return date + n;
          case Weeks:
            return date + 7*n;
          case Months: {
            Day d = date.dayOfMonth();
            Integer m = Integer(date.month())+n;
            Year y = date.year();
            while (m > 12) {
                m -= 12;
                y += 1;
            }
            while (m < 1) {
                m += 12;
                y -= 1;
            }

            QL_ENSURE(y >= 1900 && y <= 2199,
                      "year " << y << " out of bounds. "
                      << "It must be in [1901,2199]");

            Integer length = monthLength(Month(m), isLeap(y));
            if (d > length)
                d = length;

            return Date(d, Month(m), y);
          }
          case Years: {
              Day d = date.dayOfMonth();
              Month m = date.month();
              Year y = date.year()+n;

              QL_ENSURE(y >= 1900 && y <= 2199,
                        "year " << y << " out of bounds. "
                        << "It must be in [1901,2199]");

              if (d == 29 && m == February && !isLeap(y))
                  d = 28;

              return Date(d,m,y);
          }
          default:
            QL_FAIL("undefined time units");
        }
    }

 Decimal operator/(const Money& m1, const Money& m2) {
     if (m1.currency() == m2.currency()) {
         return m1.value()/m2.value();
     } else if (Money::conversionType == Money::BaseCurrencyConversion) {
         Money tmp1 = m1;
         convertToBase(tmp1);
         Money tmp2 = m2;
         convertToBase(tmp2);
         return tmp1/tmp2;
     } else if (Money::conversionType == Money::AutomatedConversion) {
         Money tmp = m2;
         convertTo(tmp, m1.currency());
         return m1/tmp;
     } else {
         QL_FAIL("currency mismatch and no conversion specified");
     }
 }

 bool close_enough(const Money& m1, const Money& m2, Size n) {
     if (m1.currency() == m2.currency()) {
         return close_enough(m1.value(),m2.value(),n);
     } else if (Money::conversionType == Money::BaseCurrencyConversion) {
         Money tmp1 = m1;
         convertToBase(tmp1);
         Money tmp2 = m2;
         convertToBase(tmp2);
         return close_enough(tmp1,tmp2,n);
     } else if (Money::conversionType == Money::AutomatedConversion) {
         Money tmp = m2;
         convertTo(tmp, m1.currency());
         return close_enough(m1,tmp,n);
     } else {
         QL_FAIL("currency mismatch and no conversion specified");
     }
 }

 void BlackCalculator::Calculator::visit(CashOrNothingPayoff& payoff) {
     black_.alpha_ = black_.DalphaDd1_ = 0.0;
     black_.x_ = payoff.cashPayoff();
     black_.DxDstrike_ = 0.0;
     switch (payoff.optionType()) {
       case Option::Call:
         black_.beta_     = black_.cum_d2_;
         black_.DbetaDd2_ = black_.n_d2_;
         break;
       case Option::Put:
         black_.beta_     = 1.0-black_.cum_d2_;
         black_.DbetaDd2_ =    -black_.n_d2_;
         break;
       default:
         QL_FAIL("invalid option type");
     }
 }

    std::vector<boost::function1<Real, Real> >
    LsmBasisSystem::pathBasisSystem(Size order, PolynomType polynomType) {

        std::vector<boost::function1<Real, Real> > ret;
        for (Size i=0; i<=order; ++i) {
            switch (polynomType) {
              case Monomial:
                  ret.push_back(MonomialFct(i));
                break;
              case Laguerre:
                ret.push_back(
                    bind(&GaussianOrthogonalPolynomial::weightedValue,
                                GaussLaguerrePolynomial(), i, _1));
                break;
              case Hermite:
                ret.push_back(
                    bind(&GaussianOrthogonalPolynomial::weightedValue,
                                GaussHermitePolynomial(), i, _1));
                break;
              case Hyperbolic:
                ret.push_back(
                    bind(&GaussianOrthogonalPolynomial::weightedValue,
                                GaussHyperbolicPolynomial(), i, _1));
                break;
              case Legendre:
                ret.push_back(
                    bind(&GaussianOrthogonalPolynomial::weightedValue,
                                GaussLegendrePolynomial(), i, _1));
                break;
              case Chebyshev:
                ret.push_back(
                    bind(&GaussianOrthogonalPolynomial::weightedValue,
                                GaussChebyshevPolynomial(), i, _1));
                break;
              case Chebyshev2nd:
                ret.push_back(
                    bind(&GaussianOrthogonalPolynomial::weightedValue,
                                GaussChebyshev2ndPolynomial(), i, _1));
                break;
              default:
                QL_FAIL("unknown regression type");
            }
        }

        return ret;
    }

 std::ostream& operator<<(std::ostream& out,
                          SwapIndex::FixingType t) {
     switch (t) {
       case SwapIndex::IsdaFixA:
         return out << "IsdaFixA";
       case SwapIndex::IsdaFixB:
         return out << "IsdaFixB";
       case SwapIndex::IfrFix:
         return out << "IfrFix";
       case SwapIndex::IsdaFixAm:
         return out << "IsdaFixAm";
       case SwapIndex::IsdaFixPm:
         return out << "IsdaFixPm";
       default:
         QL_FAIL("unknown SwapIndex::FixingType(" << QuantLib::Integer(t) << ")");
     }
 }

 boost::shared_ptr<DayCounter::Impl>
 ActualActual::implementation(ActualActual::Convention c) {
     switch (c) {
       case ISMA:
       case Bond:
         return boost::shared_ptr<DayCounter::Impl>(new ISMA_Impl);
       case ISDA:
       case Historical:
       case Actual365:
         return boost::shared_ptr<DayCounter::Impl>(new ISDA_Impl);
       case AFB:
       case Euro:
         return boost::shared_ptr<DayCounter::Impl>(new AFB_Impl);
       default:
         QL_FAIL("unknown act/act convention");
     }
 }

 SouthKorea::SouthKorea(Market market) {
     // all calendar instances share the same implementation instance
     static boost::shared_ptr<Calendar::Impl> settlementImpl(
                                           new SouthKorea::SettlementImpl);
     static boost::shared_ptr<Calendar::Impl> krxImpl(
                                                  new SouthKorea::KrxImpl);
     switch (market) {
       case Settlement:
         impl_ = settlementImpl;
         break;
       case KRX:
         impl_ = krxImpl;
         break;
       default:
         QL_FAIL("unknown market");
     }
 }

    Real FilonIntegral::integrate(const ext::function<Real (Real)>& f,
                                  Real a, Real b) const {
        const Real h = (b-a)/(2*n_);
        Array x(2*n_+1, a, h);

        const Real theta = t_*h;
        const Real theta2 = theta*theta;
        const Real theta3 = theta2*theta;

        const Real alpha = 1/theta + std::sin(2*theta)/(2*theta2)
            - 2*square<Real>()(std::sin(theta))/theta3;
        const Real beta = 2*( (1+square<Real>()(std::cos(theta)))/theta2
            - std::sin(2*theta)/theta3);
        const Real gamma = 4*(std::sin(theta)/theta3 - std::cos(theta)/theta2);

        Array v(x.size());
        std::transform(x.begin(), x.end(), v.begin(), f);

        ext::function<Real(Real)> f1, f2;
        switch(type_) {
          case Cosine:
            f1 = static_cast<Real(*)(Real)>(std::sin);
            f2 = static_cast<Real(*)(Real)>(std::cos);
            break;
          case Sine:
            f1 = static_cast<Real(*)(Real)>(std::cos);
            f2 = static_cast<Real(*)(Real)>(std::sin);
            break;
          default:
            QL_FAIL("unknown integration type");
        }

        Real c_2n_1 = 0.0;
        Real c_2n = v[0]*f2(t_*a)
            - 0.5*(v[2*n_]*f2(t_*b) + v[0]*f2(t_*a));

        for (Size i=1; i <= n_; ++i) {
            c_2n   += v[2*i]  *f2(t_*x[2*i]);
            c_2n_1 += v[2*i-1]*f2(t_*x[2*i-1]);
        }

        return h*(alpha*(v[2*n_]*f1(t_*x[2*n_]) - v[0]*f1(t_*x[0]))
                  *((type_ == Cosine) ? 1.0 : -1.0)
                 + beta*c_2n + gamma*c_2n_1);
    }

boost::shared_ptr<QuantLib::OperatorND> qlOperatorFactory::operatorND(const boost::shared_ptr<FpmlSerialized::OperatorND>& xml_serial)
{
	boost::shared_ptr<QuantLib::OperatorND> ql_oper;

	std::string operNDType = xml_serial->getType()->SValue();

	if ( operNDType == "additionOperND" )
	{
		const boost::shared_ptr<FpmlSerialized::AdditionOperND>& xml_operND
			= xml_serial->getAdditionOperND();

		ql_oper = this->additionOperND(xml_operND);
	}
	else if ( operNDType == "multipleOperND" )
	{
		const boost::shared_ptr<FpmlSerialized::MultipleOperND>& xml_operND
			= xml_serial->getMultipleOperND();

		ql_oper = this->multipleOperND(xml_operND);
	}
	else if ( operNDType == "maximumOperND" )
	{
		const boost::shared_ptr<FpmlSerialized::MaximumOperND>& xml_operND
			= xml_serial->getMaximumOperND();

		ql_oper = this->maximumOperND(xml_operND);
	}
	else if ( operNDType == "divisionOperND" )
	{
		const boost::shared_ptr<FpmlSerialized::DivisionOperND>& xml_operND
			= xml_serial->getDivisionOperND();

		ql_oper = this->divisionOperND(xml_operND);
	}
	else if ( operNDType == "identityOperND" )
	{
		ql_oper = this->identityOperND();
	}
	else
	{
		QL_FAIL("unknown operNDType : " << operNDType);
	}

	return ql_oper;
}

			QuantLib::BusinessDayConvention businessDayConvention(const std::string& typeStr)
			{
				QuantLib::BusinessDayConvention bdc;

				std::string upperStr = boost::to_upper_copy(typeStr);

				if(upperStr=="FOLLOWING")
				{
					bdc = QuantLib::Following;
				}
				else
				{
					QL_FAIL("unknown type calendar string");
				}

				return bdc;

			}

		/*! The constructor takes as inputs
		- rateTimes		the libor grid points
		- mode			the parametrization mode, see below which are available
		- parameters	generic parameters describing the parameterization, see below for their meaning for each mode
		The following values for mode are possible and the following parameters must be given:
		- mode=0: N (N=number of libors) parameters must be given. The first parameter is the skew for the next libor not yet expired,
		the second one for the libor after that and so on.
		- mode=1: 2 Parameters \f$ (b_0, lambda) \f$ must be given. The skew for the ith not expired libor (i starting with 0) is
		\f$ 1.0 - b_0 e^{-\lambda i}\f$
		*/
		PiecewiseConstantBeta(std::vector<Time>& rateTimes,
			int mode, 
			std::vector<Real>& parameters
			) : rateTimes_(rateTimes), N_(rateTimes.size()-1), parameters_(parameters), mode_(mode) {

				// set number of parameters
				switch(mode_) {
					case 0: P_=N_;
						break;
					case 1: P_=2;
						break;
					default: QL_FAIL("mode " << mode_ << " not supported.");
				}

				// initialize beta
				beta_=std::vector<double>(N_,0.0);
				setParameters();
		}

TridiagonalOperator::TridiagonalOperator(Size size) {
    if (size>=2) {
        n_ = size;
        diagonal_      = Array(size);
        lowerDiagonal_ = Array(size-1);
        upperDiagonal_ = Array(size-1);
        temp_          = Array(size);
    } else if (size==0) {
        n_ = 0;
        diagonal_      = Array(0);
        lowerDiagonal_ = Array(0);
        upperDiagonal_ = Array(0);
        temp_          = Array(0);
    } else {
        QL_FAIL("invalid size (" << size << ") for tridiagonal operator "
                "(must be null or >= 2)");
    }
}

    Real GaussJacobiPolynomial::beta(Size i) const {
        Real num = 4.0*i*(i+alpha_)*(i+beta_)*(i+alpha_+beta_);
        Real denom = (2.0*i+alpha_+beta_)*(2.0*i+alpha_+beta_)
                   * ((2.0*i+alpha_+beta_)*(2.0*i+alpha_+beta_)-1);

        if (!denom) {
            if (num != 0.0) {
                QL_FAIL("can't compute b_k for jacobi integration\n");
            } else {
                // l'Hospital
                num  = 4.0*i*(i+beta_)* (2.0*i+2*alpha_+beta_);
                denom= 2.0*(2.0*i+alpha_+beta_);
                denom*=denom-1;
                QL_ASSERT(denom, "can't compute b_k for jacobi integration\n");
            }
        }
        return num / denom;
    }

Date ComplexTimeFunctionVariableValue::calculateLastIndexFixing()
{
	if(!(this->variableBindingFlag_))
		QL_FAIL("variable is not bind");
		
	for(Size i=0;i<addedVariableValues_.size();++i)
	{
		const Date& roopDate = addedVariableValues_[i]->calculateLastIndexFixing();

		if( lastFixingDate_ < roopDate )
		{
			lastFixingDate_ = roopDate;
		}
	}

	return lastFixingDate_;
	
}

 Brazil::Brazil(Brazil::Market market) {
     // all calendar instances on the same market share the same
     // implementation instance
     static boost::shared_ptr<Calendar::Impl> settlementImpl(
                                               new Brazil::SettlementImpl);
     static boost::shared_ptr<Calendar::Impl> exchangeImpl(
                                                 new Brazil::ExchangeImpl);
     switch (market) {
       case Settlement:
         impl_ = settlementImpl;
         break;
       case Exchange:
         impl_ = exchangeImpl;
         break;
       default:
         QL_FAIL("unknown market");
     }
 }

    boost::shared_ptr<Fdm1dMesher>
    FdmVPPStepConditionFactory::stateMesher() const {
        Size nStates;
        switch (type_) {
          case Vanilla:
            nStates = 2*args_.tMinUp + args_.tMinDown;
            break;
          case StartLimit:
            nStates = FdmVPPStartLimitStepCondition::nStates(
                       args_.tMinUp,args_.tMinDown, args_.nStarts);
            break;
          default:
            QL_FAIL("vpp type is not supported");
        }

        return boost::shared_ptr<Fdm1dMesher>(
            new Uniform1dMesher(0.0, 1.0, nStates));
    }