Changeset 223

Timestamp:

07/03/08 18:44:06 (3 months ago)

Author:

snovik

Message:

New: MCAmericanEngine. Ready for the first try of monte-carlo for american options

Files:

• trunk/QLNet/QLNet/Math/Matrix.cs (modified) (4 diffs)
• trunk/QLNet/QLNet/Math/Optimization/ArmijoLineSearch.cs (modified) (2 diffs)
• trunk/QLNet/QLNet/Math/Optimization/ConjugateGradient.cs (modified) (2 diffs)
• trunk/QLNet/QLNet/Math/Optimization/LeastSquareProblem.cs (modified) (3 diffs)
• trunk/QLNet/QLNet/Math/Optimization/Simplex.cs (modified) (1 diff)
• trunk/QLNet/QLNet/Math/Optimization/SteepestDescent.cs (modified) (2 diffs)
• trunk/QLNet/QLNet/Math/Vector.cs (modified) (1 diff)
• trunk/QLNet/QLNet/Math/linearleastsquaresregression.cs (added)
• trunk/QLNet/QLNet/Math/matrixutilities (added)
• trunk/QLNet/QLNet/Math/matrixutilities/svd.cs (added)
• trunk/QLNet/QLNet/Methods/Finitedifferences/TridiagonalOperator.cs (modified) (1 diff)
• trunk/QLNet/QLNet/Methods/lattices/lattice.cs (modified) (1 diff)
• trunk/QLNet/QLNet/Methods/montecarlo/earlyexercisepathpricer.cs (modified) (1 diff)
• trunk/QLNet/QLNet/Methods/montecarlo/longstaffschwartzpathpricer.cs (modified) (2 diffs)
• trunk/QLNet/QLNet/Pricingengines/vanilla/mcamericanengine.cs (modified) (1 diff)
• trunk/QLNet/QLNet/QLNet.csproj (modified) (1 diff)
• trunk/QLNet/QLNet/Utils.cs (modified) (1 diff)

trunk/QLNet/QLNet/Math/Matrix.cs

@@ -91 +91 @@
-            #endregion
-    
-
-
-
-
-
+
+
-        public static Matrix operator +(Matrix m1, Matrix m2) { return operMatrix(ref m1, ref m2, (x, y) => x + y); }
-        public static Matrix operator -(Matrix m1, Matrix m2) { return operMatrix(ref m1, ref m2, (x, y) => x - y); }
@@ -121 +118 @@
-        }
-
-
+ 
-            if (!(v.Count == m.rows()))
-                throw new ApplicationException("vectors and matrices with different sizes ("
@@ -146 +143 @@
-                       m1.rows() + "x" + m1.columns() + ", " +
-                       m2.rows() + "x" + m2.columns() + ") cannot be multiplied");
-
-=0; i<
-=0; j<
+ 
+ = 0; i < 
+ = 0; j < 
-                    result.data_[i, j] = m1.row(i) * m2.column(j);
-            return result;
-
+
+
-
-        public static Matrix transpose(Matrix m) {
@@ -176 +174 @@
-            return result;
-        }
+
+        public void swap(int i1, int j1, int i2, int j2) {
+            double t = this[i2, j2];
+            this[i2, j2] = this[i1, j1];
+            this[i1, j1] = t;
+        }
-    }
-}

trunk/QLNet/QLNet/Math/Optimization/ArmijoLineSearch.cs

@@ -65 +65 @@
-
-            qt_ = q0;
-Utils
+Vector
-
-            // Initialize gradient
@@ -101 +101 @@
-            P.gradient(gradient_, xtd_);
-            // and it squared norm
-Utils
+Vector
-
-            // Return new step value

trunk/QLNet/QLNet/Math/Optimization/ConjugateGradient.cs

@@ -73 +73 @@
-                        // Initialize cost function, gradient g and search direction
-                        P.setFunctionValue(P.valueAndGradient(g, x_));
-                       P.setGradientNormValue(Utils
+            P.setGradientNormValue(Vector
-                        lineSearch_.searchDirection = g * -1.0;
-                        // Loop over iterations
@@ -99 +99 @@
-                                        // conjugate gradient search direction
-                                        sddiff = ((g*-1.0) + c * d) - lineSearch_.searchDirection;
-                                       normdiff = Math.Sqrt(Utils
+                    normdiff = Math.Sqrt(Vector
-                                        lineSearch_.searchDirection = (g*-1.0) + c * d;
-                                        // Now compute accuracy and check end criteria

trunk/QLNet/QLNet/Math/Optimization/LeastSquareProblem.cs

@@ -64 +64 @@
-            Vector diff = target - fct2fit;
-            // and compute the scalar product (square of the norm)
-Utils
+Vector
-        }
-        public override Vector values(Vector x)
@@ -75 +75 @@
-            // do the difference
-            Vector diff = target - fct2fit;
-Utils
+Vector
-        }
-        //! compute vector of derivatives of the least square function
@@ -107 +107 @@
-            grad_f = -2.0 * (Matrix.transpose(grad_fct2fit) * diff);
-            // and compute the scalar product (square of the norm)
-Utils
+Vector
-        }
-    }

trunk/QLNet/QLNet/Math/Optimization/Simplex.cs

@@ -36 +36 @@
-            {
-                Vector temp = vertices[i] - center;
-Utils
+Vector
-            }
-            return result / (double)(vertices.Count);

trunk/QLNet/QLNet/Math/Optimization/SteepestDescent.cs

@@ -61 +61 @@
-            P.setFunctionValue(P.valueAndGradient(gold, x_));
-            lineSearch_.searchDirection = gold*-1.0;
-Utils
+Vector
-            normdiff = Math.Sqrt(P.gradientNormValue());
-
@@ -84 +84 @@
-                // New gradient and search direction vectors
-                gdiff = gold - lineSearch_.lastGradient();
-Utils
+Vector
-                gold = lineSearch_.lastGradient();
-                lineSearch_.searchDirection = gold*-1.0;

trunk/QLNet/QLNet/Math/Vector.cs

@@ -125 +125 @@
-        //public static double operator /(Vector v1, Vector v2) { return operVector(ref v1, ref v2, (x, y) => x / y); }
-        #endregion
-    }
-
-
+
+
-        // dot product. It is already overloaded in the vector. Thus for compatibility only
- 
+
-            return v1 * v2;
-        }
-
-
-
+
-            return Vector.operVector(v1, v2, (x, y) => x * y);
-        }
-
+        public static Vector Sqrt(Vector v) {
+            Vector result = new Vector(v.size());
+            result.ForEach((i, x) => result[i] = Math.Sqrt(v[i]));
+            return result;
+        }
+
+        public void swap(int i1, int i2) {
+            double t = this[i2];
+            this[i2] = this[i1];
+            this[i1] = t;
+        }
+        #endregion
-    }
-}

trunk/QLNet/QLNet/Methods/Finitedifferences/TridiagonalOperator.cs

@@ -127 +127 @@
-            // transform(InputIterator1 start1, InputIterator1 finish1, InputIterator2 start2, OutputIterator result,
-            // BinaryOperation binary_op)
-Utils
+Vector
-
-            // matricial product

trunk/QLNet/QLNet/Methods/lattices/lattice.cs

@@ -100 +100 @@
-        public override double presentValue(DiscretizedAsset asset) {
-            int i = t_.index(asset.time());
-Utils
+Vector
-        }
-

trunk/QLNet/QLNet/Methods/montecarlo/earlyexercisepathpricer.cs

@@ -28 +28 @@
-        \ingroup mcarlo
-    */
+
+    public static class EarlyExerciseTraits<PathType> where PathType : Path {
+        //typedef Real StateType;
+        public static int pathLength(PathType path) { return path.length(); }
+    }
+
+
-    // template<class PathType, class TimeType=Size, class ValueType=Real>
-    public interface EarlyExercisePathPricer<PathType> {
-        // typedef typename EarlyExerciseTraits<PathType>::StateType StateType;
-
-double
+int
-
-double
-IValue
+int
+Func<double, double>
-    }
-}

trunk/QLNet/QLNet/Methods/montecarlo/longstaffschwartzpathpricer.cs

@@ -35 +35 @@
-              reproducing results available in web/literature
-    */
-abstract 
+
-        protected bool  calibrationPhase_;
-        protected EarlyExercisePathPricer<PathType> pathPricer_;
@@ -43 +43 @@
-
-        protected List<PathType> paths_;
-IValue
+Func<double, double>
-
+        public LongstaffSchwartzPathPricer(TimeGrid times, EarlyExercisePathPricer<PathType> pathPricer,
+                                           YieldTermStructure termStructure) {
+            calibrationPhase_ = true;
+            pathPricer_ = pathPricer;
+            coeff_ = new InitializedList<Vector>(times.size()-1);
+            dF_ = new InitializedList<double>(times.size()-1);
+            v_ = pathPricer_.basisSystem();
+
+            for (int i=0; i<times.size()-1; ++i) {
+                dF_[i] =   termStructure.discount(times[i+1])
+                         / termStructure.discount(times[i]);
+            }
+        }
-        
+
+        public override double value(PathType path) {
+            if (calibrationPhase_) {
+                // store paths for the calibration
+                paths_.Add(path);
+                // result doesn't matter
+                return 0.0;
+            }
+
+            int len = EarlyExerciseTraits<PathType>.pathLength(path);
+            double price = pathPricer_.value(path, len-1);
+            for (int i = len - 2; i > 0; --i) {
+                price*=dF_[i];
+
+                double exercise = pathPricer_.value(path, i);
+                if (exercise > 0.0) {
+                    double regValue  = pathPricer_.state(path, i);
+
+                    double continuationValue = 0.0;
+                    for (int l = 0; l < v_.Count; ++l) {
+                        continuationValue += coeff_[i][l] * v_[l](regValue);
+                    }
+
+                    if (continuationValue < exercise) {
+                        price = exercise;
+                    }
+                }
+            }
+
+            return price*dF_[0];
+        }
+
-        public void calibrate() {
-//const int n = paths_.size()
-//
-//const int len = EarlyExerciseTraits<PathType>::
+int n = paths_.Count
+
+int len = EarlyExerciseTraits<PathType>.
-
-
-
-
-
+
+
-
-//for (Size
-//    std::vector<Real>      y
-//    std::vector<StateType> x
+for (int
+    List<double> y = new List<double>()
+    List<double> x = new List<double>()
-
-//
-//    for (Size
-//        exercise[j]=(*pathPricer_)
+
+    for (int
+        exercise[j]=pathPricer_.value
-
-//
-//            x.push_back(pathPricer_->
-//            y.push_back
-//
-//
+
+            x.Add(pathPricer_.
+            y.Add
+
+
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-
-//    for (Size
-//
-//
-//            Real
-//            for (Size l=0; l<v_.size()
-//
-//
-//
-//
-//
-//
-//
-//
-//
+    for (int
+
+
+            double
+            for (int l = 0; l < v_.Count
+
+
+
+
+
+
+
+
+
-
-//
-//paths_.c
-//
-//
+
+paths_.C
+
+
-        }
-    }

trunk/QLNet/QLNet/Pricingengines/vanilla/mcamericanengine.cs

@@ -31 +31 @@
-              reproducing results available in web/literature
-    */
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
+
+
+    public class AmericanPathPricer : EarlyExercisePathPricer<Path>  {
+        protected double scalingValue_;
+        protected Payoff payoff_;
+        protected List<Func<double, double>> v_ = new List<Func<double,double>>();
+
+        public AmericanPathPricer(Payoff payoff, int polynomOrder, LsmBasisSystem.PolynomType polynomType) {
+            scalingValue_ = 1;
+            payoff_ = payoff;
+            v_ = LsmBasisSystem.pathBasisSystem(polynomOrder, polynomType);
+
+            if (!(polynomType == LsmBasisSystem.PolynomType.Monomial
+                  || polynomType == LsmBasisSystem.PolynomType.Laguerre
+                  || polynomType == LsmBasisSystem.PolynomType.Hermite
+                  || polynomType == LsmBasisSystem.PolynomType.Hyperbolic
+                  || polynomType == LsmBasisSystem.PolynomType.Chebyshev2th))
+                throw new ApplicationException("insufficient polynom type");
+
+            // the payoff gives an additional value
+            v_.Add(payoff.value);
+
+            StrikedTypePayoff strikePayoff = payoff_ as StrikedTypePayoff;
+
+            if (strikePayoff != null) {
+                scalingValue_/=strikePayoff.strike();
+            }
+        }
+
+        // scale values of the underlying to increase numerical stability
+        public double state(Path path, int t) { return path[t]*scalingValue_; }
+        public double value(Path path, int t) { return payoff(state(path, t)); }
+        public List<Func<double, double>> basisSystem() { return v_; }
+
+        protected double payoff(double state) { return state/scalingValue_; }
+    }
+
-
-    //! Monte Carlo American engine factory
-    //template <class RNG = PseudoRandom, class S = Statistics>
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-}

trunk/QLNet/QLNet/QLNet.csproj

@@ -157 +157 @@
-    <Compile Include="Math\Interpolations\multicubicspline.cs" />
-    <Compile Include="Math\Interpolations\sabrinterpolation.cs" />
+    <Compile Include="Math\linearleastsquaresregression.cs" />
-    <Compile Include="Math\Matrix.cs" />
+    <Compile Include="Math\matrixutilities\svd.cs" />
-    <Compile Include="Math\Optimization\ArmijoLineSearch.cs" />
-    <Compile Include="Math\Optimization\ConjugateGradient.cs" />

trunk/QLNet/QLNet/Utils.cs

@@ -56 +56 @@
-        }
-
+        public static void swap(ref double a1, ref double a2) { swap<double>(ref a1, ref a2); }
-        public static void swap<T>(ref T a1, ref T a2) {
-            T t = a2;