let wSpy = ibmBetaOnSpy
let wRf = 1.0-wSpy

val wSpy: float = 1.2
val wRf: float = -0.2

let hedgePortReturns =
    spy
    |> Array.map(fun spy ->
        { Time = spy.Time 
          Return = wSpy*spy.Return + wRf*riskFreeRate })

val hedgePortReturns: ReturnOb array =
  [|{ Time = 0
      Return = 0.1198 }; { Time = 1
                           Return = 0.0598 }; { Time = 2
                                                Return = -0.0242 }|]

// 3. Hedge portfolio's factor beta on SPY
// See the lecture notes for a fuller explanation:
//
// From the portfolio return equation, the
// hedge portfolio return is
// r_hedgePort = wRf * rf + wSpy * Spy
// =>
// r_hedgePort - rf = (wSpy + wRf - 1) * rf + wSpy*(Spy -rf)
// r_hedgePort - rf = wSpy*(Spy - rf)
// So the beta is
let hedgePortBetaOnSpy = ibmBetaOnSpy 

val hedgePortBetaOnSpy: float = 1.2

let hedgePortMap =
    // using map because it's efficient for lookups.
    // you could use filter with such a small collection,
    // but we'll use a Map collection so that we
    // practice like it's the real thing.
    hedgePortReturns
    |> Array.map(fun x -> x.Time, x)
    |> Map.ofArray

let longShortPortReturns =
    ibm
    |> Array.choose(fun ibmOb ->
        // We're using Array.choose instead of Array.map
        // because we plan to return Some hedgeOb or None, and we
        // want to throw away all the None cases and return just
        // an array of the valid hedgeObs. 
        let matchingHedgeReturn = Map.tryFind ibmOb.Time hedgePortMap
        // in this example matchingHedgeReturn will always be Some hedgeOb.
        // But, we're using Map.tryFind and dealing with the possibility
        // that None could happen because it's good to practice
        // as if this were real code where bad things could happen.
        match matchingHedgeReturn with
        | None -> None // if there's no hedge return for ibmOb.Time return None
        | Some hedgeOb -> 
            // if there is a matching hedge return for ibmOb.Time return Some ReturnOb
            let longShort =  ibmOb.Return - hedgeOb.Return
            Some { Time = ibmOb.Time; Return = longShort })

val hedgePortMap: Map<int,ReturnOb> =
  map
    [(0, { Time = 0
           Return = 0.1198 }); (1, { Time = 1
                                     Return = 0.0598 });
     (2, { Time = 2
           Return = -0.0242 })]
val longShortPortReturns: ReturnOb array =
  [|{ Time = 0
      Return = 0.0302 }; { Time = 1
                           Return = -0.0098 }; { Time = 2
                                                 Return = 0.0342 }|]

let alpha = 
    longShortPortReturns 
    |> Array.averageBy(fun x -> x.Return)

val alpha: float = 0.0182

#r "nuget: FSharp.Stats, 0.5.0"
open FSharp.Stats

let sdHedgeReturns =
    longShortPortReturns
    |> Array.map(fun x -> x.Return )
    |> Seq.stDev

// Intuitively, you can think of it similar
// to the sharpe ratio of the portfolio after
// hedging out the factor risk.

let io = alpha / sdHedgeReturns

[Loading C:\Users\runneradmin\.packagemanagement\nuget\Cache\ec63001b4149383af67dc5083312da4ecf34b844b655d861ca5bad281c016ede.fsx]
module FSI_0035.
       Ec63001b4149383af67dc5083312da4ecf34b844b655d861ca5bad281c016ede

val sdHedgeReturns: float = 0.02433105012
val io: float = 0.7480153922