Dear ...,

I have read Mark Joshi's book on C++ design patterns ...
My interest in the book was to try to learn how theory is put into practise. The best way to do that is by actually implementing things, so I did: I reimplemented his C++ code in OCaml, a functional, OO language that I like using. However, instead of a direct translation of C++ classes to OCaml classes, I chose a non-OO design. The result is quite interesting from the point of view of code complexity and programming productivity (and hence cost).
Here's a summary:

Monte Carlo (datatypes only)
C++: 264 lines of code (LOC), (7 classes, 20 methods), 12 files
ML : 33 LOC, (3 datatypes, 1 function), 2 files
LOC ML/C++: 33/264 = 13%
Binomial trees (datatypes only)
C++: 264 + 138 = 402 LOC, (10 classes, 30 methods), 18 files
ML : 33 + 12 = 45 LOC, (3 datatypes, 3 functions), 2 files
LOC ML/C++: 45/402 = 11%
Binomial trees (datatypes + main algorithm)
LOC ML/C++: 165/522 = 32%

I'm not claiming that Mark's C++ code is bad (actually, it's quite good). However, using a better tool results in obtaining a better final product. (Performance of Ocaml's code is competitive with C++ as well.)

Not bad. But my K implementation only uses 2 lines of code though...

EuroOpt:{[S;K;r;v;T;n;po] / spot, strike, rate, vol, expir, steps, payoff

/ initialize constants
p:(%2*m)*(1%D)-d:a-m:_sqrt -1+a*a:.5*(_exp dt*r+v*v)+D:_exp -r*dt:T%n;

/ apply n binomial steps
:*n{-1_ D*(p*1!x)+x*1-p}/K po' S*(1%d)^(2*!n+1)-n
}

...and here are some test cases...

po:{0|x-y}; / arbitrary payoff function: max(0, K-S) for put

/ compare results for n = 16, 32, 64, 128, and 256
\t EuroOpt[5;10;.06;.3;.5;;po]' _16*2^!5

/ pass in payoff functions for put, call, and digital \t 
EuroOpt[8;10;.06;.3;.5;500;]' {0|x-y},{0|y-x},{y>x}

/ investigating convergence for a digital option with 1-300 steps...
EuroOpt[8;10;.06;.3;.5;;{y>x}]' 1+!300

So yes, I agree with you. Functional languages are cool and C++ is verbose & restrictive. Unfortunately, in the real world people don't care about any of this...

Parameters& Parameters::operator=(const Parameters& original)
{
   if (this != &original)
   {   
      delete InnerObjectPtr;
      InnerObjectPtr = original.InnerObjectPtr->clone();
   }
   return *this;
}

    double averageEuro = 0.5*(euroPrice + euroNewPrice);
    double averageAmer = 0.5*(americanPrice + americanNewPrice);
    double averageForward = 0.5*(forwardPrice + forwardNewPrice);

    cout << "euro av price " << averageEuro << " amer av price " << averageAmer << "\n";
    cout << "av forward " << averageForward << "\n";

    double tmp;
    cin >> tmp;

    return 0;
}

К>Оверхед не пройдёт!

pivot=: 4 : 0
'r c'=. x.
col=. c{"1 y.
y. - (col-r=i.#y.) */ (r{y.)%r{col
)
simplex=: 3 : 0
min=. i. <./
m=. y.
while.
  r0=. }:{.m
  c=. min r0
  0 > c{r0
do.
  t=. {:"1 m
  d=. c{"1 m
  f=. (0 > d){0 _    
  r=. min f + t % d
  m=. (r,c) pivot m
end.
)

X = Y + Z

1. Записать это нормальным человеческим языком:

   Положь колдобину со стороны загогулины и два раза дергани за пимпочку. Опосля чего долбани плюхалкой по кувывалке и, коды чвокнет, отскочь дальшее...

2. Нарисовать весь процесс картинками.
   Рисовать не буду, т.к. не умею, да и в общем случае только картинками без словесных пояснений не обойтись.

X = Y + Z

# НМС
#
# Комментарий:
# Положь колдобину со стороны загогулины и два раза дергани за пимпочку. 
# Опосля чего долбани плюхалкой по кувывалке и, коды чвокнет, отскочь дальшее...
@>!%~&^
2 {;)`
?/$&*

# Великий И Могучий

# Управление Штуковиной
Положь: колдобину со_стороны загогулины
2 раза: дергани за пимпочку
долбани: плюхалкой по кувывалке
коды чвокнет, отскочь дальшее

GN>X = Y + Z
GN>

# НМС
X = Y + Z

#  ВиМ
# X = Y + Z
возьми чаво там в Y
прибавь к нему то, что в Z
то что получилось зафигач в X