added Lexifi contracts (incomplete)

This commit adds the contracts used by the Generic Pricing engine
from Lexifi to the code (together with a description).
Two of the three contracts have been implemented so far, and one
of them requires division on the RealE type (not implemented yet).

Author: jberthold

Haskell/Contract/Expr.hs

@@ -203,6 +203,13 @@ instance MkExpr Int where
 instance MkExpr Double where
     constr = R
 
+-- | Fractional instance for Expr Double, enables fractional literals
+-- (and division, not used yet)
+instance (MkExpr a, Fractional a) => Fractional (Expr a) where
+    (/) = undefined -- arith Div, when we have a division operator
+    -- recip x = 1 / x -- default
+    fromRational x = constr (fromRational x)
+
 -- the smart constructors of the interface
 
 i = I -- :: Int  -> IntE

Haskell/LexifiContracts.hs

@@ -0,0 +1,56 @@
+
+-- contracts from Lexifi, used with the generic pricing engine
+
+module LexifiContracts
+    where
+
+-- MEMO: clean up imports and exports of umbrella file "Contract.hs"
+import Contract
+import Contract.Type
+import Contract.Date
+import Contract.Expr
+
+-- European option on DJ_Eurostoxx_50, starting 
+european :: MContract
+european = (start, -- 2011-12-09
+            transl duration -- on 2012-11-30
+                (scale (maxx 0 (obs (idx,0) - strike))
+                        (transfOne EUR "them" "us")))
+            where start    = at "2011-12-09" :: Date
+                  duration = dateDiff start (at "2012-11-30")
+                             -- MEMO this fct. should be called "daysBetween"
+                  idx      = "DJ_Eurostoxx_50"
+                  strike   = 4000
+
+-- worst-off contract on five fixed dates (chain of iff)
+worstOff :: MContract
+worstOff = (start, foldr mkDateCheck endCase (zip dDiffs premiums))
+    where start  = at "2012-01-27"
+          dates  = map (\s -> at (show s ++ "-01-27")) [2013..2017]
+          dDiffs   = zipWith dateDiff (start:dates) dates
+          premiums = [1150.0, 1300.0, 1450.0, 1600.0, 1750]
+          -- on the five dates (offset): one below initial spot => pay premium
+          mkDateCheck (offset, premium) cont
+              = transl offset $ iff barrier (collectEUR premium) cont
+          barrier = nott (foldl1 minn (zipWith mkDiff idxs spots) !<! 0)
+          -- MEMO we should have <= , > and >= as smart constructors
+          mkDiff idx spot = obs (idx, 0) - spot
+           -- MEMO we should have RealE division.
+          idxs   = [ "DJ_Eurostoxx_50", "Nikkei_225", "SP_500" ]
+          spots  = [ 3758.05, 11840, 1200 ]
+          -- if end (date 5) reached: pay 1000 if all above 0.75,
+          -- otherwise pay the fraction of the worst (HOW? no division)
+          endCase = iff (allAbove 0.75) (collectEUR 1000) 
+                        (collectEUR (1000 * minRatio))
+          minRatio = error "cannot define minimum ratio without division"
+          allAbove d = nott (foldl1 (!|!) 
+                             (zipWith (fractionSmaller d) idxs spots))
+           {- 0.75 < minimum [ obs(id,0) / sp | (id, sp) <- zip idxs spots ]
+                               <==> 
+              and [ 0.75 * sp !<! obs (id, 0) | (id, sp) <- zip idxs spots ]
+                               <==> 
+            not (or [obs(id, 0) !<! 0.75 * sp | (id, sp) <- zip idxs spots]) -}
+          fractionSmaller d idx spot = obs(idx, 0) !<! d * spot
+          collectEUR amount = scale amount (transfOne EUR "them" "us")
+
+--

lexifi-contracts.txt

@@ -58,7 +58,7 @@ previously fixed amount, depending on which date it was (premiums),
 and end the contract. Otherwise continue with the next date.
 
 If test on all five dates failed (at least one was below start on each
-date), test if all indexes were at least 75% of the start value. In
+date), test on last date if all indexes are at least 75% of start. In
 this case, pay 1000 (end of discounted_payoffs). Otherwise, pay
 (1000*worst percentage).