// a regular named record
type ExampleRec = { X : int; Y : int }
let r = { X = 1; Y = 2}
// an anonymous record. The difference is
// 1. We did not define the type ahead of time.
// 2. We put the pipe symbole "|" inside the curly braces.
let ar = {| X = 1; Y = 2|}
// Note that they are not the same type, so if you
// compare them they will be different even though
// the X and Y fields have the same values.
// For example, running `r = ar` 
// will give a compiler error

type ExampleRec =
  {
    X: int
    Y: int
  }
val r: ExampleRec = { X = 1
                      Y = 2 }
val ar: {| X: int; Y: int |} = { X = 1
                                 Y = 2 }

// 1.

// Option 1: here I will explicitly put year and month in the final result
arr 
|> List.groupBy(fun x -> x.Date.Year, x.Date.Month)
|> List.map(fun ((year, month), xs) ->
    let minValue = 
        xs 
        |> List.map(fun x -> x.Value)
        |> List.min
    (year, month), minValue) // explicitly put it in the result

// or Option 1:
// since I'm just returning the grouping variable, there's really
// no need to deconstruct it into year, month at any point.
arr 
|> List.groupBy(fun x -> x.Date.Year, x.Date.Month)
|> List.map(fun (group, xs) -> // match group to (year,month) together
    let minValue = 
        xs 
        |> List.map(fun x -> x.Value)
        |> List.min
    group, minValue)

// 2. Now using anonymous records
// This is where anonymous records can be useful.
// For example, sometimes grouping by many things, 
// using anonymous records like this make it more clear what the different
// grouping variables are because they have names.
// It's like a middle ground between tuples with no clear naming structure
// and regular named records that are very explicit.

arr 
|> List.groupBy(fun x -> {| Year = x.Date.Year; Month = x.Date.Month |})
|> List.map(fun (group, xs) -> 
    let minValue = 
        xs 
        |> List.map(fun x -> x.Value)
        |> List.min
    {| Group = group; Value = minValue |})

val it: {| Group: {| Month: int; Year: int |}; Value: float |} list =
  [{ Group = { Month = 1
               Year = 1990 }
     Value = 1.25 }; { Group = { Month = 1
                                 Year = 1991 }
                       Value = 3.25 }]

// Remember that portfolio returns are a weighted average
// of the returns of the stocks in the portfolio. The weights
// are the position weights.

// Option 1:
let stockAndBondPort = 
    stockPos.Weight*stockPos.Return + bondPos.Weight*bondPos.Return

// Option 2: or, doing the multiplication and summation with collections
let weightXreturn =
    [ for pos in [ stockPos; bondPos ] do pos.Weight * pos.Return ]
// look at it
weightXreturn
// now sum
let stockAndBondPort2 = weightXreturn |> List.sum
// check
stockAndBondPort = stockAndBondPort2 // evaluates to true

val stockAndBondPort: float = 0.0625
val weightXreturn: float list = [0.025; 0.0375]
val stockAndBondPort2: float = 0.0625
val it: bool = true

// Option 1:
let threeAssetPortfolioReturn =
    positions
    |> List.map(fun pos -> pos.Weight*pos.Return)
    |> List.sum

// Option 2:
let threeAssetPortfolioReturn2 =
    positions
    |> List.sumBy(fun pos -> pos.Weight*pos.Return)

// Option 3:
let threeAssetPortfolioReturn3 =
    [ for pos in positions do pos.Weight * pos.Return ]
    |> List.sum

val threeAssetPortfolioReturn: float = 0.01
val threeAssetPortfolioReturn2: float = 0.01
val threeAssetPortfolioReturn3: float = 0.01

let positionsWithShortReturn =
    positionsWithShort
    |> List.map(fun pos -> pos.Weight*pos.Return)
    |> List.sum

val positionsWithShortReturn: float = -0.175

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

let retsAvg = rets |> List.average
// we get stDev from FSharp.Stats
let retsStdDev = rets |> stDev 
let retsSharpeRatio = retsAvg / retsStdDev

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

val retsAvg: float = 0.004
val retsStdDev: float = 0.241516045
val retsSharpeRatio: float = 0.01656204663

// remember that to annualize an arithmetic return,
// we do return * (# compounding periods per year)
// to annualize a standard deviation, 
// we do sd * sqrt(# compounding periods per year)

let monthlyRetsAnnualizedAvg = 12.0*(rets |> List.average)
// or
let monthlyRetsAnnualizedAvg2 = 
    rets 
    |> List.average 
    // now we're going to use a lambda expression.
    // this is the same idea as when we do Array.map(fun x -> ...)
    // except now we're only piping a float, not an array so
    // we're leaving off the "Array.map" 
    |> (fun avg -> 12.0 * avg) 
// or, in two steps
let monthlyRetsAvg = rets |> List.average
let monthlyRetsAnnualizedAvg3 = 12.0*monthlyRetsAvg

// now the standard deviation
let monthlyRetsAnnualizedSd = 
    rets 
    |> stDev
    |> fun monthlySd -> sqrt(12.0) * monthlySd
//or, in two steps
let monthlyRetsSd = rets |> stDev
let monthlyRetsAnnualizedSd2 = sqrt(12.0)*monthlyRetsSd

// SharpeRatio
let annualizedSharpeFromMonthly =
    monthlyRetsAnnualizedAvg / monthlyRetsAnnualizedSd

// or, since 12.0/sqrt(12.0) = sqrt(12.0) then
// (monthlyRetsAvg *12.0)/(monthlyRetsSd*sqrt(12.0)) = 
//      sqrt(12.0)*(monthlyRetsAvg/monthlyRetsSd)
let annualizedSharpeFromMonthly2 =
    sqrt(12.0) * (monthlyRetsAvg / monthlyRetsSd)

// check
// we have to round because floating point math gives us slightly different #'s
// recall from the fundamentals lecture how floating point math is inexact.
Math.Round(annualizedSharpeFromMonthly,6) = Math.Round(annualizedSharpeFromMonthly2,6) // true

val monthlyRetsAnnualizedAvg: float = 0.048
val monthlyRetsAnnualizedAvg2: float = 0.048
val monthlyRetsAvg: float = 0.004
val monthlyRetsAnnualizedAvg3: float = 0.048
val monthlyRetsAnnualizedSd: float = 0.8366361216
val monthlyRetsSd: float = 0.241516045
val monthlyRetsAnnualizedSd2: float = 0.8366361216
val annualizedSharpeFromMonthly: float = 0.05737261249
val annualizedSharpeFromMonthly2: float = 0.05737261249
val it: bool = true

// Convention for daily is 252 trading days per year.
// so annualize daily by multiplying by sqrt(252.0)
let annualizedSharpeFromDaily =
    let avgRet = rets |> List.average
    let stdevRet = rets |> stDev
    sqrt(252.0) * (avgRet/stdevRet)
// or in multiple steps
let dailyAvgRet = rets |> List.average
let dailyStDevRet = rets |> stDev
let annualizedSharpeFromDaily2 =
    sqrt(252.0) * (dailyAvgRet/dailyStDevRet)

val annualizedSharpeFromDaily: float = 0.2629143395
val dailyAvgRet: float = 0.004
val dailyStDevRet: float = 0.241516045
val annualizedSharpeFromDaily2: float = 0.2629143395

let mu = 0.1
let sigma = 0.2
let gamma = 3.0
let riskyWeight = mu / (gamma * sigma ** 2.0)

val mu: float = 0.1
val sigma: float = 0.2
val gamma: float = 3.0
val riskyWeight: float = 0.8333333333