Ejemplo n.º 1
0
    public async Task<PortfolioPnlCache> GetCurrentAllocatedExposureHistPnl(CarbonClient cc_, bool forcerefresh_ = false)
    {
      if (m_currentExpBackwards != null && !forcerefresh_)
        return m_currentExpBackwards.Value;

      var exp = await GetLatestAllocatedExposure(cc_, forcerefresh_);

      // if we haven't got exposure
      if (exp == null || exp.Item2 == null)
      {
        m_currentExpBackwards = new TriedObject<PortfolioPnlCache>();
        return null;
      }

      var listOfColumns = new List<string>();
      var listOfDailyReturns = new List<DatedDataCollectionGen<double>>();

      for (int i = 0; i < exp.Item2.Length; ++i)
      {
        var exposureName = exp.Item1[i];
        var exposure = exp.Item2[i];

        if (exposure.IsZero())
          continue;

        listOfColumns.Add(exposureName);

        // get the security master
        var secMaster = await SecMasters.Get(exposureName, cc_);

        // find equivalent TRS object
        var trInstrument = (secMaster == null) ? null : await secMaster.TRInstrument(cc_);

        // get TRS object's history
        var series = trInstrument == null ? null : await trInstrument.GetTimeSeries(cc_);

        if (series == null)
        {
          Logger.Error(string.Format("Could not find total return series for [{0}]", exposureName), typeof(Portfolio));
          continue;
        }

        var dailyIncrements = series.ToReturns();

        if (secMaster.Invert)
          dailyIncrements = dailyIncrements.MultiplyBy(-1d);

        listOfDailyReturns.Add(dailyIncrements.MultiplyBy(exposure));
      }

      var con = new ConstructGenGen<DateTime, double>(listOfColumns.ToArray());
      for (int i = 0; i < con.ArrayLength; ++i)
        con.SetColumnValues(i, listOfDailyReturns[i].Dates, listOfDailyReturns[i].Data);

      con.Keys.Sort((a, b) => a.CompareTo(b));

      m_currentExpBackwards = new TriedObject<PortfolioPnlCache>(new PortfolioPnlCache(new SysTimeSeries { Data = con }));

      return m_currentExpBackwards.Value;
    }
    private void analyse()
    {
      if (m_lastApplied == null)
        return;

      seasAverageNormalized.ClearSeries();
      seasProbability.ClearSeries();

      var allLevels = m_lastApplied.GetCombined(DataAroundEventField.Filled_Level);
      var allDiffs = m_lastApplied.GetCombined(DataAroundEventField.Filled_Daily_Diff);

      var subsetLevels = new ConstructGenGen<int, double>(allLevels.ColumnHeadings);
      var subsetDiffs = new ConstructGenGen<int, double>(allLevels.ColumnHeadings);

      //
      // get all the values for the subset that's been defined
      //

      foreach (var indexPoint in allLevels.Keys)
      {
        if (indexPoint < m_args.AnalysisStartIndex)
          continue;

        if (indexPoint > m_args.AnalysisEndIndex)
          break;

        subsetLevels.SetValues(indexPoint, allLevels.GetValues(indexPoint));
        subsetDiffs.SetValues(indexPoint, allDiffs.GetValues(indexPoint));
      }

      //
      // calculate and apply probabilities
      //

      var probType = ProbabilityCalcType.UpsMinusDownsOverNumber;
      var probabilities = new double[subsetDiffs.Keys.Count];

      for (int i = 0; i < subsetDiffs.Keys.Count; ++i)
      {
        var valsForIndexPoint = allDiffs.GetValues(allDiffs.Keys[i]);
        probabilities[i] = ProbabilityCalc.CalcProb(valsForIndexPoint, probType);
      }

      // add probability column chart

      seasProbability.AddColumnChart("Probability", subsetLevels.Keys.Select(x => x.ToString()).ToArray(),
        probabilities, ProbabilityCalc.GetMaxValue(probType));
      seasProbability.AddLegend();
    

      // 
      // calculate normlized series on subset
      //

      var normdValues = new ConstructGenGen<int, double>(allLevels.ColumnHeadings);
      var keys = subsetLevels.Keys.Select(x => x.ToString()).ToArray();

      for(int i=0;i<subsetLevels.ArrayLength;++i)
      {
        var normd = subsetLevels.GetColumnValues(i).Normalize();

        normdValues.SetColumnValues(i, subsetLevels.Keys.ToArray(), normd);
      }

      //
      // calculate average normalized series
      //

      var averageNorms = new double[normdValues.Keys.Count];
      //var dispersionMeasure = new double[normdValues.Keys.Count];

      for (int i = 0; i < averageNorms.Length; ++i)
      {
        var valuesToUse = normdValues.GetValues(normdValues.Keys[i]).Where(x => double.IsNaN(x) == false).ToArray();

        averageNorms[i] = valuesToUse.Average();
        //dispersionMeasure[i] = Statistics.Stdev(valuesToUse.Select(x=>x-averageNorms[i]).ToArray());
      }

      // 
      // normalize the average and display
      //

      averageNorms = averageNorms.Normalize();

      seasAverageNormalized.AddLineChart("Seasonal pattern", keys, averageNorms);
      //seasAverageNormalized.AddColumnChart("stdev", keys, dispersionMeasure, dispersionMeasure.Max());

      seasAverageNormalized.AddLegend();
    }