rank.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div></div><div></div><div><strong>Installed Packages</strong><ul><li><span>FSharp.Data, 4.2.3</span></li><li><span>FSharp.Stats, 0.4.2</span></li><li><span>Microsoft.Data.Analysis, 0.18.0</span></li></ul></div></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2500\n",
      "299\n",
      "{ MaxPrice = 0.0037567330768351681840691783M\n",
      "  LastATHTime = 1612051200000UL\n",
      "  DrawDownPeriod = 251UL\n",
      "  ATHStreak = 0UL\n",
      "  DrawDownPeriodCount = 1UL\n",
      "  DrawDownPeriodSum = 287UL\n",
      "  DrawDowns = [|{ Time = 1633737600000UL\n",
      "                  Period = 21686400000UL\n",
      "                  DrawDown = 0.7637816590271088508840417486M }|] }\n",
      "\"BZRXUSDT\"\n",
      "\"GTCUSDT\"\n",
      "\"CVCUSDT\"\n",
      "\"JSTUSDT\"\n",
      "\"BEARUSDT\"\n",
      "\"NEARUSDT\"\n",
      "\"VIDTUSDT\"\n",
      "\"STORJUSDT\"\n",
      "\"XTZUSDT\"\n",
      "\"BELUSDT\"\n",
      "\"DYDXUSDT\"\n",
      "\"CVPUSDT\"\n",
      "\"JUVUSDT\"\n",
      "\"FILUSDT\"\n",
      "\"PERLUSDT\"\n",
      "\"TRIBEUSDT\"\n",
      "\"VITEUSDT\"\n",
      "\"DUSKUSDT\"\n",
      "\"1INCHUSDT\"\n",
      "\"ATMUSDT\"\n",
      "\"PAXUSDT\"\n",
      "\"AAVEUSDT\"\n",
      "\"C98USDT\"\n",
      "\"MANAUSDT\"\n",
      "\"STORMUSDT\"\n",
      "\"XVGUSDT\"\n",
      "\"FIDAUSDT\"\n",
      "\"TRBUSDT\"\n",
      "\"GTOUSDT\"\n",
      "\"REQUSDT\"\n",
      "\"REPUSDT\"\n",
      "\"NEOUSDT\"\n",
      "\"ATOMUSDT\"\n",
      "\"LUNAUSDT\"\n",
      "\"ACMUSDT\"\n",
      "\"EGLDUSDT\"\n",
      "\"DAIUSDT\"\n",
      "\"AUDIOUSDT\"\n",
      "\"BETAUSDT\"\n",
      "\"MASKUSDT\"\n",
      "\"STPTUSDT\"\n",
      "\"NKNUSDT\"\n",
      "\"RIFUSDT\"\n",
      "\"XVSUSDT\"\n",
      "\"AUDUSDT\"\n",
      "\"DASHUSDT\"\n",
      "\"CAKEUSDT\"\n",
      "\"GXSUSDT\"\n",
      "\"KAVAUSDT\"\n",
      "\"VTHOUSDT\"\n",
      "\"BKRWUSDT\"\n",
      "\"FIOUSDT\"\n",
      "\"TROYUSDT\"\n",
      "\"CELOUSDT\"\n",
      "\"ADAUSDT\"\n",
      "\"PERPUSDT\"\n",
      "\"ELFUSDT\"\n",
      "\"KEEPUSDT\"\n",
      "\"HARDUSDT\"\n",
      "\"NULSUSDT\"\n",
      "\"BLZUSDT\"\n",
      "\"CELRUSDT\"\n",
      "\"NMRUSDT\"\n",
      "\"WANUSDT\"\n",
      "\"FIROUSDT\"\n",
      "\"ENJUSDT\"\n",
      "\"RLCUSDT\"\n",
      "\"CHRUSDT\"\n",
      "\"HCUSDT\"\n",
      "\"AUTOUSDT\"\n",
      "\"WAXPUSDT\"\n",
      "\"DATAUSDT\"\n",
      "\"STRATUSDT\"\n",
      "\"XZCUSDT\"\n",
      "\"KLAYUSDT\"\n",
      "\"FLMUSDT\"\n",
      "\"HNTUSDT\"\n",
      "\"KNCUSDT\"\n",
      "\"MATICUSDT\"\n",
      "\"AKROUSDT\"\n",
      "\"ALICEUSDT\"\n",
      "\"BNBBULLUSDT\"\n",
      "\"OCEANUSDT\"\n",
      "\"SUSDUSDT\"\n",
      "\"AGLDUSDT\"\n",
      "\"YGGUSDT\"\n",
      "\"YFIUSDT\"\n",
      "\"POLYUSDT\"\n",
      "\"TUSDUSDT\"\n",
      "\"CKBUSDT\"\n",
      "\"DEGOUSDT\"\n",
      "\"FORUSDT\"\n",
      "\"RUNEUSDT\"\n",
      "\"MCOUSDT\"\n",
      "\"HOTUSDT\"\n",
      "\"MDXUSDT\"\n",
      "\"OGNUSDT\"\n",
      "\"MFTUSDT\"\n",
      "\"LENDUSDT\"\n",
      "\"ANKRUSDT\"\n",
      "\"BARUSDT\"\n",
      "\"SUSHIUSDT\"\n",
      "\"TRUUSDT\"\n",
      "\"PHAUSDT\"\n",
      "\"EOSBULLUSDT\"\n",
      "\"RSRUSDT\"\n",
      "\"WINUSDT\"\n",
      "\"MBLUSDT\"\n",
      "\"AVAXUSDT\"\n",
      "\"DENTUSDT\"\n",
      "\"BONDUSDT\"\n",
      "\"DFUSDT\"\n",
      "\"BALUSDT\"\n",
      "\"CLVUSDT\"\n",
      "\"PSGUSDT\"\n",
      "\"STXUSDT\"\n",
      "\"TVKUSDT\"\n",
      "\"BNTUSDT\"\n",
      "\"AXSUSDT\"\n",
      "\"ERDUSDT\"\n",
      "\"FRONTUSDT\"\n",
      "\"POLSUSDT\"\n",
      "\"EPSUSDT\"\n",
      "\"WNXMUSDT\"\n",
      "\"ALPHAUSDT\"\n",
      "\"FLOWUSDT\"\n",
      "\"KSMUSDT\"\n",
      "\"QNTUSDT\"\n",
      "\"ZENUSDT\"\n",
      "\"BTCUSDT\"\n",
      "\"ICPUSDT\"\n",
      "\"DIAUSDT\"\n",
      "\"UMAUSDT\"\n",
      "\"SANDUSDT\"\n",
      "\"COMPUSDT\"\n",
      "\"OGUSDT\"\n",
      "\"SFPUSDT\"\n",
      "\"ETCUSDT\"\n",
      "\"SYSUSDT\"\n",
      "\"WTCUSDT\"\n",
      "\"ARDRUSDT\"\n",
      "\"UNIUSDT\"\n",
      "\"BCCUSDT\"\n",
      "\"ZRXUSDT\"\n",
      "\"BTSUSDT\"\n",
      "\"DOCKUSDT\"\n",
      "\"COTIUSDT\"\n",
      "\"ETHBULLUSDT\"\n",
      "\"CFXUSDT\"\n",
      "\"EOSBEARUSDT\"\n",
      "\"HIVEUSDT\"\n",
      "\"CHZUSDT\"\n",
      "\"NPXSUSDT\"\n",
      "\"HBARUSDT\"\n",
      "\"STRAXUSDT\"\n",
      "\"WINGUSDT\"\n",
      "\"YFIIUSDT\"\"AVAUSDT\"\n",
      "\"FISUSDT\"\n",
      "\n",
      "\"KEYUSDT\"\n",
      "\"BNBBEARUSDT\"\n",
      "\"ROSEUSDT\"\n",
      "\"NUUSDT\"\n",
      "\"KMDUSDT\"\n",
      "\"DCRUSDT\"\n",
      "\"WAVESUSDT\"\n",
      "\"IDEXUSDT\"\n",
      "\"MIRUSDT\"\n",
      "\"SHIBUSDT\"\n",
      "\"LINKUSDT\"\n",
      "\"FTTUSDT\"\n",
      "\"QTUMUSDT\"\n",
      "\"OMUSDT\"\n",
      "\"USDCUSDT\"\n",
      "\"TCTUSDT\"\n",
      "\"XECUSDT\"\n",
      "\"ARPAUSDT\"\n",
      "\"ARUSDT\"\n",
      "\"ONEUSDT\"\n",
      "\"ALGOUSDT\"\n",
      "\"ALPACAUSDT\"\n",
      "\"PONDUSDT\"\n",
      "\"LITUSDT\"\n",
      "\"MITHUSDT\"\n",
      "\"ILVUSDT\"\n",
      "\"FUNUSDT\"\n",
      "\"BCHABCUSDT\"\n",
      "\"ASRUSDT\"\n",
      "\"BNBUSDT\"\n",
      "\"BTTUSDT\"\n",
      "\"CRVUSDT\"\n",
      "\"DODOUSDT\"\n",
      "\"AIONUSDT\"\n",
      "\"ZECUSDT\"\n",
      "\"CTKUSDT\"\n",
      "\"LRCUSDT\"\n",
      "\"ETHUSDT\"\n",
      "\"SKLUSDT\"\n",
      "\"MLNUSDT\"\n",
      "\"CTXCUSDT\"\n",
      "\"XMRUSDT\"\n",
      "\"USDPUSDT\"\n",
      "\"UNFIUSDT\"\n",
      "\"FARMUSDT\"\n",
      "\"COSUSDT\"\n",
      "\"SXPUSDT\"\n",
      "\"OXTUSDT\"\n",
      "\"QUICKUSDT\"\n",
      "\"REEFUSDT\"\n",
      "\"BTCSTUSDT\"\n",
      "\"DEXEUSDT\"\n",
      "\"PNTUSDT\"\n",
      "\"MINAUSDT\"\n",
      "\"TKOUSDT\"\n",
      "\"TOMOUSDT\"\n",
      "\"BEAMUSDT\"\n",
      "\"USDSUSDT\"\n",
      "\"GNOUSDT\"\n",
      "\"OMGUSDT\"\n",
      "\"ZILUSDT\"\n",
      "\"BTGUSDT\"\n",
      "\"FTMUSDT\"\n",
      "\"WRXUSDT\"\n",
      "\"MDTUSDT\"\n",
      "\"TRXUSDT\"\n",
      "\"INJUSDT\"\n",
      "\"GALAUSDT\"\n",
      "\"ONGUSDT\"\n",
      "\"IOSTUSDT\"\n",
      "\"IOTXUSDT\"\n",
      "\"XEMUSDT\"\n",
      "\"ONTUSDT\"\n",
      "\"TFUELUSDT\"\n",
      "\"TWTUSDT\"\n",
      "\"SUNUSDT\"\n",
      "\"DGBUSDT\"\n",
      "\"ERNUSDT\"\n",
      "\"ANTUSDT\"\n",
      "\"BCHSVUSDT\"\n",
      "\"BATUSDT\"\n",
      "\"DNTUSDT\"\n",
      "\"ETHBEARUSDT\"\n",
      "\"FORTHUSDT\"\n",
      "\"MBOXUSDT\"\n",
      "\"MKRUSDT\"\n",
      "\"LPTUSDT\"\n",
      "\"BULLUSDT\"\n",
      "\"DOGEUSDT\"\n",
      "\"COCOSUSDT\"\n",
      "\"DREPUSDT\"\n",
      "\"EOSUSDT\"\n",
      "\"BUSDUSDT\"\n",
      "\"LINAUSDT\"\n",
      "\"BANDUSDT\"\n",
      "\"GBPUSDT\"\n",
      "\"NANOUSDT\"\n",
      "\"SNXUSDT\"\n",
      "\"ICXUSDT\"\n",
      "\"ATAUSDT\"\n",
      "\"BAKEUSDT\"\n",
      "\"PUNDIXUSDT\"\n",
      "\"RVNUSDT\"\n",
      "\"SCUSDT\"\n",
      "\"LSKUSDT\"\n",
      "\"CTSIUSDT\"\n",
      "\"SLPUSDT\"\n",
      "\"XRPBEARUSDT\"\n",
      "\"MTLUSDT\"\n",
      "\"EURUSDT\"\n",
      "\"USDSBUSDT\"\n",
      "\"PAXGUSDT\"\n",
      "\"FETUSDT\"\n",
      "\"RENUSDT\"\n",
      "\"RADUSDT\"\n",
      "\"TORNUSDT\"\n",
      "\"TLMUSDT\"\n",
      "\"GRTUSDT\"\n",
      "\"UTKUSDT\"\n",
      "\"IRISUSDT\"\n",
      "\"XLMUSDT\"\n",
      "\"IOTAUSDT\"\n",
      "\"THETAUSDT\"\n",
      "\"ORNUSDT\"\n",
      "\"DOTUSDT\"\n",
      "\"GHSTUSDT\"\n",
      "\"SOLUSDT\"\n",
      "\"LTCUSDT\"\n",
      "\"XRPBULLUSDT\"\n",
      "\"RAMPUSDT\"\n",
      "\"VENUSDT\"\n",
      "\"SRMUSDT\"\n",
      "\"XRPUSDT\"\n",
      "\"RAYUSDT\"\n",
      "\"VETUSDT\"\n",
      "\"BCHUSDT\"\n",
      "\"BURGERUSDT\"\n",
      "\"NBSUSDT\"\n",
      "\"STMXUSDT\"\n",
      "\"LTOUSDT\"\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "System.IndexOutOfRangeException: Index was outside the bounds of the array.\n   at FSharp.Stats.JaggedArray.initializer@1-2[T](T[][] arr, Int32 rowI) in C:\\Users\\bvenn\\source\\repos\\FSharp.Stats\\src\\FSharp.Stats\\JaggedArray.fs:line 25\n   at FSharp.Stats.JaggedArray.transpose[T](T[][] arr) in C:\\Users\\bvenn\\source\\repos\\FSharp.Stats\\src\\FSharp.Stats\\JaggedArray.fs:line 25\n   at <StartupCode$FSI_0108>.$FSI_0108.main@()",
     "output_type": "error",
     "traceback": [
      "System.IndexOutOfRangeException: Index was outside the bounds of the array.\n",
      "   at FSharp.Stats.JaggedArray.initializer@1-2[T](T[][] arr, Int32 rowI) in C:\\Users\\bvenn\\source\\repos\\FSharp.Stats\\src\\FSharp.Stats\\JaggedArray.fs:line 25\n",
      "   at FSharp.Stats.JaggedArray.transpose[T](T[][] arr) in C:\\Users\\bvenn\\source\\repos\\FSharp.Stats\\src\\FSharp.Stats\\JaggedArray.fs:line 25\n",
      "   at <StartupCode$FSI_0108>.$FSI_0108.main@()"
     ]
    }
   ],
   "source": [
    "// purpose of this notebook:\n",
    "// to find coins that have the highest likelihood of going up with the least amount of new capital inflows\n",
    "\n",
    "// data we need:\n",
    "// 1. total coin market cap ovet time\n",
    "// 2. a list of coins\n",
    "// 3. the market cap of those coins over\n",
    "\n",
    "// what we do with that data:\n",
    "// * convert the coin market caps of each coin into a dominance %\n",
    "// * calculate the time since the last the coin last hit peak dominance\n",
    "// * multiply the dominance % by the time since the last peak\n",
    "// * sort the coins in descending order of the product of the dominance % and the time since the last peak\n",
    "\n",
    "#r \"nuget: FSharp.Data\"\n",
    "#r \"nuget: Microsoft.Data.Analysis\"\n",
    "#r \"nuget: FSharp.Stats\"\n",
    "\n",
    "open FSharp.Data\n",
    "open FSharp.Stats\n",
    "\n",
    "type BinanceExchangeInfo = JsonProvider<\"https://api.binance.com/api/v3/exchangeInfo\">\n",
    "type PriceStream = JsonProvider<\"https://api.binance.com/api/v3/klines?symbol=1INCHDOWNUSDT&interval=1d\">\n",
    "type CoinGecko = JsonProvider<\"https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=250&page=1&sparkline=false\">\n",
    "\n",
    "let show a =\n",
    "    printf \"%A\\n\" a\n",
    "\n",
    "type MarketCap = \n",
    "    { Symbol: string\n",
    "    ; MarketCap: int64\n",
    "    ; Rank: int }\n",
    "\n",
    "let geckoByPage (page:int) = \n",
    "    CoinGecko.Load(\"https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=100&page=\" + page.ToString() + \"&sparkline=false\")\n",
    "\n",
    "let geckoSubByPage page =\n",
    "    geckoByPage page\n",
    "    |> Array.map (fun x -> { Symbol = x.Symbol; MarketCap = x.MarketCap; Rank = x.MarketCapRank })\n",
    "\n",
    "let geckoSub =\n",
    "    //[|1..25|]\n",
    "    [|1..25|]\n",
    "    |> Array.fold (fun acc x -> Array.append acc (geckoSubByPage x)) Array.empty\n",
    "    |> Array.sortBy (fun x -> x.Symbol)\n",
    "\n",
    "show geckoSub.Length\n",
    "\n",
    "let exchInfo = BinanceExchangeInfo.Load(\"https://api.binance.com/api/v3/exchangeInfo\")\n",
    "    \n",
    "let assets = \n",
    "    exchInfo.Symbols \n",
    "    |> Array.filter (fun x-> x.QuoteAsset.IndexOf(\"USDT\") <> -1 )\n",
    "    |> Array.filter (fun x-> x.BaseAsset.IndexOf(\"UP\") = -1 && x.BaseAsset.IndexOf(\"DOWN\") = -1) \n",
    "    |> Array.filter (fun x-> x.BaseAsset.IndexOf(\"BADGER\") = -1)\n",
    "    |> Array.map (fun x -> x.Symbol) \n",
    "    |> Array.sort\n",
    "    //|> Array.take 20\n",
    "\n",
    "show assets.Length\n",
    "\n",
    "type Candle = \n",
    "    { Time : uint64\n",
    "    ; Open : decimal\n",
    "    ; High:  decimal\n",
    "    ; Low : decimal\n",
    "    ; Close: decimal }\n",
    "    \n",
    "let makeCandle (assetRow:(decimal array)) =\n",
    "    { Time = (uint64)assetRow.[0]\n",
    "    ; Open = assetRow.[1]\n",
    "    ; High = assetRow.[2]\n",
    "    ; Low = assetRow.[3]\n",
    "    ; Close = assetRow.[4] }\n",
    "\n",
    "let assetHistory symbol (limit:int) =\n",
    "    PriceStream.Load(\"https://api.binance.com/api/v3/klines?symbol=\" + symbol + \"&interval=1d&limit=\" + limit.ToString())\n",
    "    |> Array.map makeCandle\n",
    "\n",
    "let ethHistory = \n",
    "    assetHistory \"ETHUSDT\" 1000\n",
    "\n",
    "let ethPricedAssetHistory limit symbol = \n",
    "    let asset = assetHistory symbol limit\n",
    "    let eth = \n",
    "        ethHistory\n",
    "        |> Array.skip (ethHistory.Length - asset.Length)\n",
    "\n",
    "    asset\n",
    "    |> Array.zip eth\n",
    "    |> Array.map (fun (ethRow, assetRow) -> \n",
    "        { Time = assetRow.Time\n",
    "        ; Open = assetRow.Open / ethRow.Open\n",
    "        ; High = assetRow.High / ethRow.High\n",
    "        ; Low = assetRow.Low / ethRow.Low\n",
    "        ; Close = assetRow.Close / ethRow.Close })\n",
    "\n",
    "let ath assetHistory = \n",
    "    assetHistory \n",
    "    |> Array.maxBy (fun x -> x.High)\n",
    "\n",
    "let timeSinceLastAth now assetHistory =\n",
    "    let lastAth = (ath assetHistory).Time\n",
    "    now - lastAth\n",
    "\n",
    "let daysSinceLastAth now assetHistory =\n",
    "    (timeSinceLastAth now assetHistory) / (24UL * 60UL * 60UL) / 1000UL\n",
    "\n",
    "type DrawDownPeriod = \n",
    "    { Time: uint64\n",
    "    ; Period: uint64 }\n",
    "\n",
    "type DrawDown =\n",
    "    { Time: uint64\n",
    "    ; Period: uint64 \n",
    "    ; DrawDown: decimal }\n",
    "\n",
    "type DrawDownState =\n",
    "    { MaxPrice: decimal\n",
    "    ; LastATHTime : uint64\n",
    "    ; DrawDownPeriod : uint64\n",
    "    ; ATHStreak: uint64\n",
    "    ; DrawDownPeriodCount: uint64\n",
    "    ; DrawDownPeriodSum: uint64\n",
    "    ; DrawDowns: array<DrawDown> }\n",
    "\n",
    "let drawDownAnalysis assetHistory =\n",
    "    let drawDownPeriods state candle = \n",
    "        if state.MaxPrice = 0M then\n",
    "            { MaxPrice = candle.Close \n",
    "            ; LastATHTime = candle.Time\n",
    "            ; DrawDownPeriod = 0UL\n",
    "            ; ATHStreak = 1UL\n",
    "            ; DrawDownPeriodCount = 1UL\n",
    "            ; DrawDownPeriodSum = 0UL\n",
    "            ; DrawDowns = \n",
    "                [| { Time = candle.Time\n",
    "                ; Period = 0UL\n",
    "                ; DrawDown = 0M } |] }\n",
    "        else\n",
    "            if candle.Close > state.MaxPrice then\n",
    "                { MaxPrice = candle.Close \n",
    "                ; LastATHTime = candle.Time\n",
    "                ; DrawDownPeriod = 0UL\n",
    "                ; ATHStreak = state.ATHStreak + 1UL\n",
    "                ; DrawDownPeriodCount = \n",
    "                    if state.ATHStreak = 0UL then\n",
    "                        state.DrawDownPeriodCount\n",
    "                    else\n",
    "                        state.DrawDownPeriodCount + 1UL\n",
    "                ; DrawDownPeriodSum =  state.DrawDownPeriodSum\n",
    "                ; DrawDowns = \n",
    "                    [| { Time = candle.Time\n",
    "                    ; Period = 0UL \n",
    "                    ; DrawDown = 0M } |] }\n",
    "            else\n",
    "                { MaxPrice = state.MaxPrice\n",
    "                ; LastATHTime = state.LastATHTime\n",
    "                ; DrawDownPeriod = state.DrawDownPeriod + 1UL\n",
    "                ; ATHStreak = 0UL\n",
    "                ; DrawDownPeriodCount = state.DrawDownPeriodCount\n",
    "                ; DrawDownPeriodSum = state.DrawDownPeriodSum + 1UL\n",
    "                ; DrawDowns = \n",
    "                    [| { Time = candle.Time\n",
    "                    ; Period = candle.Time - state.LastATHTime\n",
    "                    ; DrawDown = (state.MaxPrice - candle.Close) / state.MaxPrice } |] }\n",
    "    assetHistory \n",
    "    |> Array.fold \n",
    "        drawDownPeriods \n",
    "        { MaxPrice = 0M\n",
    "        ; LastATHTime = 0UL\n",
    "        ; DrawDownPeriod = 0UL\n",
    "        ; ATHStreak = 0UL\n",
    "        ; DrawDownPeriodCount = 0UL\n",
    "        ; DrawDownPeriodSum = 0UL\n",
    "        ; DrawDowns = Array.empty }\n",
    "\n",
    "\"1INCHUSDT\" |> ethPricedAssetHistory 1000 |> drawDownAnalysis |> show\n",
    "\n",
    "\n",
    "type assetAthDays = \n",
    "    { Asset: string\n",
    "    ; MarketCap: int64\n",
    "    ; Rank: int\n",
    "    ; DaysSinceLastAth: uint64\n",
    "    ; ATHStreak: uint64\n",
    "    ; Order: float \n",
    "    ; DrawDownPeriodCount: uint64\n",
    "    ; AverageDrawDown: decimal \n",
    "    ; ROI: decimal \n",
    "    }\n",
    "\n",
    "let allDaysSinceLastAth limit ignoreLast ROIPeriod assetList = \n",
    "    assetList\n",
    "    |> Array.Parallel.map (fun (asset:string) -> \n",
    "        show asset\n",
    "\n",
    "        let ast = asset.Replace(\"USDT\", \"\").ToLowerInvariant()\n",
    "\n",
    "        let ethPriceHistory = \n",
    "            asset |> ethPricedAssetHistory limit \n",
    "        \n",
    "        let cap = \n",
    "            geckoSub \n",
    "            |> Array.filter (fun x -> x.Symbol = ast.ToLowerInvariant())\n",
    "            |> Array.sumBy (fun x -> x.MarketCap)\n",
    "\n",
    "        let rank = \n",
    "            geckoSub \n",
    "            |> Array.filter (fun x -> x.Symbol = ast.ToLowerInvariant())\n",
    "            |> Array.distinctBy (fun x -> x.Symbol)\n",
    "            |> Array.sumBy (fun x -> x.Rank)\n",
    "\n",
    "        let dsath = \n",
    "            ethPriceHistory\n",
    "            |> daysSinceLastAth ethHistory.[ethHistory.Length - 1].Time\n",
    "\n",
    "        let averageDrawDown =\n",
    "            let daysToTake = Math.Max(1, ethPriceHistory.Length - ignoreLast)\n",
    "            ethPriceHistory |> Array.take daysToTake |> drawDownAnalysis\n",
    "\n",
    "        let order = \n",
    "            //(float(dsath) + 1.0) * float(cap)\n",
    "            //Math.Pow((float(dsath) + 1.0), 2.0) / float(rank) \n",
    "            Math.Floor(float(abs (int64(averageDrawDown.DrawDownPeriod) - 34L)) / float(averageDrawDown.DrawDownPeriodCount))\n",
    "\n",
    "        let ROI =\n",
    "            let last = ethPriceHistory.[ethPriceHistory.Length - 1] \n",
    "            let tailLength = Math.Min(ROIPeriod, ethPriceHistory.Length)\n",
    "            let first = ethPriceHistory.[ethPriceHistory.Length - tailLength]\n",
    "            last.Close / first.Close \n",
    "\n",
    "        { Asset = ast\n",
    "        ; MarketCap = cap / 1000000L\n",
    "        ; Rank = rank\n",
    "        ; DaysSinceLastAth = averageDrawDown.DrawDownPeriod // (60UL * 60UL * 24UL * 1000UL)\n",
    "        ; ATHStreak = averageDrawDown.ATHStreak\n",
    "        ; Order = order \n",
    "        ; DrawDownPeriodCount = averageDrawDown.DrawDownPeriodCount\n",
    "        ; AverageDrawDown = decimal(averageDrawDown.DrawDownPeriodSum) / decimal(averageDrawDown.DrawDownPeriodCount)\n",
    "        ; ROI = ROI \n",
    "        })\n",
    "\n",
    "let momentum period (candles: Candle array) =\n",
    "    let momentumOverArray (candles: Candle array) =\n",
    "        if candles.Length < 1 then\n",
    "            0M\n",
    "        else\n",
    "            candles.[candles.Length - 1].Close / candles.[0].Close\n",
    "\n",
    "    candles \n",
    "    |> Array.windowed period\n",
    "    |> Array.map (fun x -> \n",
    "        {| Time = x.[0].Time\n",
    "        ;  Momentum = momentumOverArray x \n",
    "        |})\n",
    "\n",
    "type Momentum = \n",
    "    { Asset: string\n",
    "    ; Time: uint64\n",
    "    ; Momentum: decimal }\n",
    "\n",
    "let assetMomentums historyPeriod momentumPeriod assets =\n",
    "    assets\n",
    "    |> Array.Parallel.map (fun (asset:string) -> \n",
    "        show asset\n",
    "\n",
    "        let ast = asset.Replace(\"USDT\", \"\").ToLowerInvariant()\n",
    "\n",
    "        let ethPriceHistory = \n",
    "            asset |> ethPricedAssetHistory historyPeriod \n",
    "\n",
    "        let momentum = \n",
    "            ethPriceHistory \n",
    "            |> momentum momentumPeriod\n",
    "\n",
    "        momentum\n",
    "        |> Array.map (fun x -> \n",
    "            { Asset = ast\n",
    "            ; Time = x.Time\n",
    "            ; Momentum = x.Momentum\n",
    "            }))\n",
    "\n",
    "let minTime a = \n",
    "    a |> Array.minBy (fun x -> x.Time) |> fun x -> x.Time\n",
    "\n",
    "let maxTime a = \n",
    "    a |> Array.maxBy (fun x -> x.Time) |> fun x -> x.Time\n",
    "\n",
    "let matrix m n a = \n",
    "    Array2D.init (minTime a) (maxTime a) (fun x y -> \n",
    "        let x' = x - minTime a\n",
    "        let y' = y - minTime\n",
    "        a.[x'][y'])\n",
    "\n",
    "let transposeJaggedArray f arr =\n",
    "    let firstByF\n",
    "        \n",
    "\n",
    "\n",
    "// |> Array.map (fun c -> \n",
    "//     c \n",
    "//     |> Array.sortBy (fun x -> x.Momentum) \n",
    "//     |> Array.take 10)\n",
    "\n",
    "// let transposedAssetMomentums assets =\n",
    "//     assets\n",
    "//     |> Array.transpose\n",
    "\n",
    "//     assets |> assetMomentums 60 |> transposedAssetMomentums |> show\n",
    "\n",
    "// let set = \n",
    "//     assets  \n",
    "//     //|> Array.take 5\n",
    "//     |> allDaysSinceLastAth 1000 0 365\n",
    "//     |> Array.filter (fun x -> x.MarketCap <> 0L)\n",
    "//     |> Array.sortByDescending (fun x -> x.DaysSinceLastAth)\n",
    "//     |> Array.take 20\n",
    "//     // |> Array.map (fun x -> x.AverageDrawDown)\n",
    "//     // |> Array.average\n",
    "\n",
    "// set\n",
    "// // |> Array.map (fun x -> x.Asset.ToUpperInvariant() + \"USDT\")\n",
    "// // |> allDaysSinceLastAth 2 0\n",
    "// // |> Array.sortBy (fun x -> x.Last30DayROI)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90"
  },
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "file_extension": ".cs",
   "mimetype": "text/x-csharp",
   "name": "C#",
   "pygments_lexer": "csharp",
   "version": "9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}