SERVING THE QUANTITATIVE FINANCE COMMUNITY

  • 1
  • 2
  • 3
  • 4
  • 5
  • 13
 
User avatar
Polter
Posts: 2526
Joined: April 29th, 2008, 4:55 pm

Using Quantlib

March 29th, 2014, 6:54 pm

pcaspers, you can use KKT, although note that the solution is at the _saddle_ point of the Lagrangian function (_not_ at its optimum):http://eaton.math.rpi.edu/faculty/Mitch ... l.htmlThus, I wouldn't expect the "just give the Lagrangian to an optimizer" approach to work in general.Perhaps you can consider the augmented Lagrangian method:http://ab-initio.mit.edu/wiki/index.php ... _algorithm
 
User avatar
pcaspers
Posts: 695
Joined: June 6th, 2005, 9:49 am

Using Quantlib

March 30th, 2014, 10:52 am

thanks for these references, Polter.for at least part of the problems occuring in quantitative finance (like a parameter being positive or bounded) it seems that often ad hoc transformations can be (and are ?) successfully used to rewrite the respective problem in unconstrained form.
Last edited by pcaspers on March 29th, 2014, 11:00 pm, edited 1 time in total.
 
User avatar
Cuchulainn
Topic Author
Posts: 59986
Joined: July 16th, 2004, 7:38 am
Location: Amsterdam
Contact:

Using Quantlib

March 31st, 2014, 4:48 pm

QuoteOriginally posted by: pcaspersQuoteOriginally posted by: CuchulainnCould we we write the problem in Lagrange multiplier form to get an unconstrained and then apply DE? Then we can accomodate more general constraints as well? When you say "the problem" are you referring to a specific one or speaking generally ?afaik Lagrange multiplier apply to constraints F( X ) = 0. Does it extend to F( X ) < c ?I am looking at (3) Boundary Constraints in DE at the moment. In this case, instead of a constraint class I initialise the population matrix (NP X ND) with U(L,R) for eachg individual in the population in my C++ code. Since we want a global minimum (multi-modal problems) we use DE with enough mutation etc. A good test is Rosenbrock<N> (when 4 <= N <= 7 we have 1 global and 1 local minimum). I have tested to N = 50 to get (1,1,....,1).RosenbrockThe other constraints are:(1) inequality(2) equality(2) (and indeed (3) is a special case of (1) and the Penalty Method (as in American option PDE) can be used, next. Then I (nor QL) would not need constraint classes and make things a bit easier.For the moment, G2++ (to take a random example) has constraints of type (3) only?(?)A question is : does QL have code for the C++ cost function that I can bind to with my DE code? (it will save me writing it all)The signature is double Cost(const "std::vector-compatible-class"& arr ) ( I use uBLAS). When my code is complete I can send it to QL if you like.
Last edited by Cuchulainn on March 30th, 2014, 10:00 pm, edited 1 time in total.
 
User avatar
Cuchulainn
Topic Author
Posts: 59986
Joined: July 16th, 2004, 7:38 am
Location: Amsterdam
Contact:

Using Quantlib

July 2nd, 2014, 8:04 pm

Luigi,Is the installation of QL on VS2013 easy?grazie
 
User avatar
CptanPanic
Posts: 11
Joined: June 23rd, 2010, 8:21 pm

Using Quantlib

September 11th, 2014, 6:53 pm

I am on windows and would like to use QuantLib with Python and SWIG, but I would rather not have to install VSC++ and Boost, etc. Is there a prebuilt version of 1.4 available?
 
User avatar
tagoma
Posts: 18260
Joined: February 21st, 2010, 12:58 pm

Using Quantlib

September 12th, 2014, 8:25 am

QuoteOriginally posted by: CptanPanicI am on windows and would like to use QuantLib with Python and SWIG, but I would rather not have to install VSC++ and Boost, etc. Is there a prebuilt version of 1.4 available???
 
User avatar
Cuchulainn
Topic Author
Posts: 59986
Joined: July 16th, 2004, 7:38 am
Location: Amsterdam
Contact:

Using Quantlib

June 20th, 2016, 2:09 pm

The Visual Studio VS2015 installation with QL 1.8 installed without problems. Not even a compiler warning.Now I am trying to gather the code, data sets and background to QL code for Longstaff-Schwartz LeastSquares for Bermudan option, CVA and CCR. I have found some slide shows but am more interested in the algorithms.In the short term we wish to reproduce the results and see how it goes from there.Any pointers? thanks
 
User avatar
pcaspers
Posts: 695
Joined: June 6th, 2005, 9:49 am

Using Quantlib

June 20th, 2016, 5:25 pm

here is one pointer
 
User avatar
Cuchulainn
Topic Author
Posts: 59986
Joined: July 16th, 2004, 7:38 am
Location: Amsterdam
Contact:

Using Quantlib

June 21st, 2016, 7:58 am

QuoteOriginally posted by: pcaspershere is one pointerThanks.I have compiled this into QL. I now need to create an instance of LSPP class with a path evolver and a yield term structure. Are there 101 test data/programs for this?
Last edited by Cuchulainn on June 20th, 2016, 10:00 pm, edited 1 time in total.
 
User avatar
pcaspers
Posts: 695
Joined: June 6th, 2005, 9:49 am

Using Quantlib

June 22nd, 2016, 5:23 am

look in the test suite for american option pricing, there is an (equity) example; there are also lots of examples in the market model tests (but they are actually using different classes for LS); and there will be more, I am sure, maybe just grep McLongstaffSchwartzEngine or LongstaffSchwartzPathPricer.
 
User avatar
Cuchulainn
Topic Author
Posts: 59986
Joined: July 16th, 2004, 7:38 am
Location: Amsterdam
Contact:

Re: Using Quantlib

October 25th, 2017, 1:12 pm

Are there any plans at any time for QL under C++11? 
The current design uses many of the GOF patterns from the 1990s as I discussed once (you may remember)  at one QL meeting.

It will be difficult for GOF to adapt, so IMO something should be done. In fact, they are not the main metaphor any more.
A number of GOF patterns (e.g. Observer, Command) are basically just wrong. And you don't need class hierarchies.
(For the record, the GOF patterns I have migrated/made redundant to a next gen style. So, It's not a brainstorming post here!)

The functional programming metaphor is closer to algorithmic thinking than OOP. And it has a natural 1:1 mapping to multitasking with std::future.
 
User avatar
Cuchulainn
Topic Author
Posts: 59986
Joined: July 16th, 2004, 7:38 am
Location: Amsterdam
Contact:

Re: Using Quantlib

November 2nd, 2017, 6:33 pm

An example to show delegates and super-easy interface. We don't need to use SWIG and GOF Observer replaced by events .
Another option is put C# code in an assembly and then open the assembly from CLI.
The other way around (wrap C++ to CLI) is also easy.

This could be done with QL quite easily, e.g. wrap C++ Calendar.or BVN etc.Whatever.

// ClockSubscriber.cpp
//
// Usiing .Net delegates instead of GOF Observer and call the .Net code
// from C++/CLI and native C++. Means we don't need SWIG?
//
// Ported from C#. Creata CLR Console and run.
//
// (C) Datasim Education BV  2002-2018


using namespace System;
using namespace System::Threading;

public ref class TimeChangeEventArgs : EventArgs
{
public:
 DateTime dt;

 TimeChangeEventArgs(DateTime dt)
 { // Constructor

 this->dt = dt;
 }
};


public ref class Clock
{
public:
 // Define event delegate
 delegate void TimeChangeEventHandler(Object^ sender, TimeChangeEventArgs^ e);

 // Event variable to store subscribers. Note, it also works without the "event" keyword but with "event" the framework can make a distintion
 event TimeChangeEventHandler^ OnTimeChange;

 void Run()
 {

 for (;; Thread::Sleep(1000)) // Infinite loop, sleeps every iteration for 1000 ms
 {
 // Get the current time
 TimeChangeEventArgs^ args = gcnew TimeChangeEventArgs(DateTime::Now);

 // Raise event and call event methods
 // C# and C++/CLI versions
 // if (OnTimeChange != nullptr) OnTimeChange(this, args); // Necessary to check for null 
 OnTimeChange(this, args); // Not necessary to check for null
 }
 }
};

public ref class ClockSubscriber
{
public:
 static void DisplayTime1(Object^ sender, TimeChangeEventArgs^ args)
 { // TimeChangeEventHandler 1

 Console::WriteLine("DisplayTime 1: {0}", args->dt);
 }

 static void DisplayTime2(Object^ sender, TimeChangeEventArgs^ args)
 { // TimeChangeEventHandler 2

 // Display time with an offset
 int h = 24; int d = 0; int m = 0;
 TimeSpan ts(h, d, m);

 Console::WriteLine("Offset, DisplayTime 2: {0}", args->dt + ts);
 }
};


int main()
{
 // Create clock instance
 Clock^ clock = gcnew Clock();

 // Subscribe event handlers for Clock.TimeChangeEvent
 clock->OnTimeChange += gcnew Clock::TimeChangeEventHandler(ClockSubscriber::DisplayTime1);
 clock->OnTimeChange += gcnew Clock::TimeChangeEventHandler(ClockSubscriber::DisplayTime2);

 // Start the clock
 clock->Run();

 return 0;
}
 
User avatar
Cuchulainn
Topic Author
Posts: 59986
Joined: July 16th, 2004, 7:38 am
Location: Amsterdam
Contact:

Re: Using Quantlib

November 3rd, 2017, 11:02 am

I had a quick look at SWIG; it allows you to call C/C++ code from C# by creating an interface file and compiling it into an unmanaged dll that you can call using PINVOKE. Fair enough But ... why not let the compiler do it for you automagically into a reflective/self-describing .Net assembly? SWIG has a bit 80s feel (IDL etc.)

I have not used SWIG but I suspect maintaining all those interfaces is an issue?

Take an example of the Genz West BVN algo we call from C#. We create an assembly in C++/CLI and call it from C#.  As sanity check, we did a test of the output from here: 

viewtopic.php?f=34&t=83376

Just one more thing .. you can write C++ code + QL and call .NET code. Not sure if SWIG can.
// ManagedWrapper.hpp
//
// C++/CLI wrapper class for a native C++ class
//
// (C) Datasim Education BV 2018
//

#pragma once

#include <string>
#include <memory>

#include <ql/quantlib.hpp>
#include <ql/math/distributions/bivariatenormaldistribution.cpp>
using NativeClass = QuantLib::BivariateCumulativeNormalDistributionWe04DP;

using namespace System;

namespace Wrapper
{

 // ManagedWrapper has similar interface as the native class that it wraps
 public ref class ManagedWrapper
 {
 private:
 NativeClass* m_nativeClass; // The embedded native class
 // std::unique_ptr<NativeClass> m_nativeClass; // mixed types not possible!
 double _rho;

 public:

 // Constructor with data
 ManagedWrapper(double rho) : _rho(rho)
 {
 // Create native class instance with data
 m_nativeClass =  new NativeClass(_rho);
 }

 double Compute(double a, double b)
 {
 return  (*m_nativeClass)(a, b);
 }

 // Get- and set data as property
 property double Correlation
 {
 double get() { return _rho; }
 void set(double value) 
 { 
 _rho = value; 

 delete m_nativeClass;
 m_nativeClass = new NativeClass(_rho); 
 }
 }

 !ManagedWrapper()
 {
 delete m_nativeClass;
 }

 ~ManagedWrapper()
 {
 this->!ManagedWrapper();
 }
 };
}

// Program


using Wrapper;

class MainClass
{
 static void Main(string[] args)
 {
 /* double x=0.25;
 int k=0;

 // Uniform distributions
 UniformDistribution myUniform=new UniformDistribution(0.0, 1.0);
 Console.WriteLine("Lower value: {0}, Upper value: {1}", myUniform.Lower(), myUniform.Upper());

 Console.WriteLine("pdf of Uniform: {0}", BoostMath.Pdf(myUniform, x));
 Console.WriteLine("cdf of Uniform: {0}", BoostMath.Cdf(myUniform, x));
 Console.WriteLine();

 // Bernoulli distributions
 BernoulliDistribution myBernoulli=new BernoulliDistribution(0.4);
 Console.WriteLine("Probability of success: {0}", myBernoulli.SuccessFraction());

 Console.WriteLine("pdf of Bernoulli: {0}", BoostMath.Pdf(myBernoulli, k));
 Console.WriteLine("cdf of Bernoulli: {0}", BoostMath.Cdf(myBernoulli, k));
 Console.WriteLine();

 // Chi squared distributions
 ChiSquaredDistribution myChiSquared=new ChiSquaredDistribution(0.4);

 Console.WriteLine("pdf of ChiSquared: {0}", BoostMath.Pdf(myChiSquared, 2));
 Console.WriteLine("cdf of ChiSquared: {0}", BoostMath.Cdf(myChiSquared, 2));
 Console.WriteLine();
 */

 // Non central chi squared distributions
 NonCentralChiSquaredDistribution myNonCentralChiSquared = new NonCentralChiSquaredDistribution(2, 2);

 Console.WriteLine("pdf of NonCentralChiSquared: {0}", BoostMath.Pdf(myNonCentralChiSquared, 2));
 Console.WriteLine("cdf of NonCentralChiSquared: {0}", BoostMath.Cdf(myNonCentralChiSquared, 2));
 Console.WriteLine();

 // C# code here: Check output data from chapter 16, section 16.4
 ManagedWrapper mw = new ManagedWrapper(0.948175);
 Console.WriteLine("rho {0}", mw.Correlation);
 Console.WriteLine("value {0}", mw.Compute(-4.7346574, 3.0501621));

 mw.Correlation = 0.17220467;
 Console.WriteLine("rho {0}", mw.Correlation);
 Console.WriteLine("value {0}", mw.Compute(-2.726639, 4.9965896));

 mw.Correlation = 0.054292586;
 Console.WriteLine("rho {0}", mw.Correlation);
 Console.WriteLine("value {0}", mw.Compute(-1.946981, 3.1876528));

 }
}
 
User avatar
Cuchulainn
Topic Author
Posts: 59986
Joined: July 16th, 2004, 7:38 am
Location: Amsterdam
Contact:

Re: Using Quantlib

December 16th, 2017, 10:10 am

 boost::mt19937 mt;
 mt.seed(static_cast<boost::uint32_t> (std::time(0)));
 boost::normal_distribution<> distribution;
 boost::variate_generator<boost::mt19937&, boost::normal_distribution<>>
 normal(mt, distribution);

 std::mt19937 dre;
 dre.seed(static_cast<boost::uint32_t> (std::time(0)));
 std::normal_distribution<double> nor(0.0, 1.0);
I've noticed something interesting with QL and Monte Carlo, QL uses Boost RNG and I move RNG to C++11 (essentially changing the namesapace in  a straightforward way). 

1. C++ 11 MT, Knuth are 6 times slower than Boost MT.
2. Boost MT _seems_ to be less accurate than Boost RNG).

Not knowing the details of these algorithms makes it difficult to say why.
 
User avatar
outrun
Posts: 4573
Joined: April 29th, 2016, 1:40 pm

Re: Using Quantlib

December 16th, 2017, 12:15 pm

What are your compiler settings? 64bit?

Do they generate the same sequence when given the same seed? What you are saying with "less accurate" is that it is biased and you are the first to observe that. That in turn means that it's deviating from the documented MT with has been extensively tested for its statistical properties. That is all a bit unlikely. How did you measure "accuracy" of the boost MT? Is it eg an observed statistical significant deviation from expected sample noise?

variate_generator is an old interface, you can be C++11 compliant by not using it. When the C++11 <random> standard came out it was based in boost, but with differences. Boost implemented the new standard interface and definitions to be compatible with the C++11 standard, and also left things in for backward compatibility.
ABOUT WILMOTT

PW by JB

Wilmott.com has been "Serving the Quantitative Finance Community" since 2001. Continued...


Twitter LinkedIn Instagram

JOBS BOARD

JOBS BOARD

Looking for a quant job, risk, algo trading,...? Browse jobs here...


GZIP: On