American-transaction costs 1.0.0.0 American option pricer under proportional transaction costs

- Main Page
- Namespaces
- Classes
- Files
- Directories

- File List
- File Members

piecewiselinear.h
Go to the documentation of this file.

    00001 /*
    00002     American option pricer under proportional transaction costs
    00003     Copyright (C) 2011 Alet Roux alet.roux@york.ac.uk
    00004
    00005     This program is free software: you can redistribute it and/or modify
    00006     it under the terms of the GNU General Public License as published by
    00007     the Free Software Foundation, either version 3 of the License, or
    00008     (at your option) any later version.
    00009
    00010     This program is distributed in the hope that it will be useful,
    00011     but WITHOUT ANY WARRANTY; without even the implied warranty of
    00012     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00013     GNU General Public License for more details.
    00014
    00015     You should have received a copy of the GNU General Public License
    00016     along with this program.  If not, see <http://www.gnu.org/licenses/>.
    00017
    00018 */
    00019
    00020
    00021 #ifndef PIECEWISELINEAR_H
    00022 #define PIECEWISELINEAR_H
    00023
    00029 #include <vector>
    00030
    00031 #include "line.h"
    00032
    00034 typedef std::vector<Line> line_array;
    00035
    00036 //#include <iostream>
    00037
    00039 #define PIECEWISELINEAR_CHECK_MAXIMUM 1
    00040
    00042 #define PIECEWISELINEAR_CHECK_MINIMUM 2
    00043
    00045
    00049 class PiecewiseLinear
    00050 {
    00051 public:
    00053         PiecewiseLinear (const Line &line = Line (NAN, NAN))
    00054         {
    00055                 _lines.push_back (line);
    00056                 check();
    00057         }
    00058
    00060         PiecewiseLinear (const line_array &lines)
    00061                         : _lines (lines)
    00062         {
    00063                 check();
    00064         }
    00065
    00067         Line operator[] (const size_t k) const
    00068         {
    00069                 return _lines[k];
    00070         }
    00071
    00073         coefficient operator() (const coefficient x) const
    00074         {
    00075                 return _lines[piece (x) ] (x);
    00076         }
    00077
    00081         size_t piece (const coefficient x) const
    00082         {
    00083                 size_t k = 0;
    00084                 while (greaterequal (x,intersection (k+1)))
    00085                         k++;
    00086                 return k;
    00087         }
    00088
    00090         PiecewiseLinear& operator*= (const coefficient value)
    00091         {
    00092                 for (size_t k = 0; k < size(); k++)
    00093                         _lines[k] *= value;
    00094                 return *this;
    00095         }
    00096
    00098         PiecewiseLinear& operator= (const line_array &lines)
    00099         {
    00100                 _lines = lines;
    00101                 check();
    00102                 return *this;
    00103         }
    00104
    00106         int operator>= (const PiecewiseLinear& function)
    00107         {
    00108                 if (function.slope (0) < slope (0))
    00109                         return 0;
    00110
    00111                 if (function.slope (function.size()-1) > slope (size()-1))
    00112                         return 0;
    00113
    00114                 for (size_t k = 1; k < size(); k++)
    00115                         if (lessthan (operator() (intersection (k)),function (intersection (k))))
    00116                                 return 0;
    00117
    00118                 for (size_t k = 1; k < function.size(); k++)
    00119                         if (lessthan (operator() (function.intersection (k)),function (function.intersection (k))))
    00120                                 return 0;
    00121
    00122                 return 1;
    00123         }
    00124
    00126         size_t size() const
    00127         {
    00128                 return _lines.size();
    00129         }
    00130
    00133         inline coefficient intersection (const size_t k) const
    00134         {
    00135                 return _intersections[k];
    00136         }
    00137
    00139         coefficient slope (const size_t k) const
    00140         {
    00141                 return _lines[k].slope();
    00142         }
    00143
    00145         coefficient intercept (const size_t k) const
    00146         {
    00147                 return _lines[k].intercept();
    00148         }
    00149
    00154         void shift (const coefficient x, const coefficient y)
    00155         {
    00156                 for (size_t k = 0; k < size(); k++)
    00157                         _lines[k].shift (x, y);
    00158
    00159                 for (size_t k = 1; k < size(); k++)
    00160                         _intersections[k] = _intersections[k] + x;
    00161         }
    00162
    00164         void negate()
    00165         {
    00166                 for (size_t k = 0; k < size(); k++)
    00167                         _lines[k].negate();
    00168         }
    00169
    00174         void restrict_slope (const coefficient lowest, const coefficient highest);
    00175
    00177         int convex() const
    00178         {
    00179                 for (size_t k = 1; k < size(); k++)
    00180                         if (lessthan (slope (k),slope (k-1)))
    00181                                 return 0;
    00182                 return 1;
    00183         }
    00184
    00185 protected:
    00190         void check (const int objective = PIECEWISELINEAR_CHECK_MAXIMUM);
    00191
    00192 private:
    00193         line_array _lines;
    00194
    00195         std::vector<coefficient> _intersections;
    00196 };
    00197
    00199 std::ostream& operator<< (std::ostream& output, const PiecewiseLinear& line);
    00200
    00202 #define PIECEWISELINEAR_CROSSING_LEFT -1
    00203
    00205 #define PIECEWISELINEAR_CROSSING_RIGHT 1
    00206
    00208 coefficient crossing (const Line &line, const PiecewiseLinear &function, const coefficient x = -INFINITY, const int direction = PIECEWISELINEAR_CROSSING_RIGHT);
    00209
    00215 PiecewiseLinear maximum (PiecewiseLinear &first, PiecewiseLinear &second);
    00216
    00222 inline PiecewiseLinear minimum (PiecewiseLinear &first, PiecewiseLinear &second)
    00223 {
    00224         first.negate();
    00225         second.negate();
    00226
    00227         PiecewiseLinear minimum = maximum (first, second);
    00228
    00229         first.negate();
    00230         second.negate();
    00231         minimum.negate();
    00232
    00233         return minimum;
    00234 }
    00235
    00237 void print_convex_conjugate (const PiecewiseLinear& line);
    00238
    00243 void untangle_maximum (const PiecewiseLinear& f, const std::vector<PiecewiseLinear>& g, const coefficient y, coefficient& w, std::vector<coefficient>& p, std::vector<coefficient>& x);
    00244
    00245 #endif // PIECEWISELINEAR_H

All Classes Namespaces Files Functions Variables Typedefs Defines