An-attempt-to-approach-market-capitalization-from-a-different-perspective

CODE:

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using System.Collections.Generic;
using System.IO;
using System.Globalization;
using System.Linq;

namespace WealthScript2
{
   public class MarketCapRotationFinal : UserStrategyBase
   {
      private Dictionary<string, double> _sharesMap = new Dictionary<string, double>();
      private List<string> _top5 = new List<string>();

      public override void Initialize(BarHistory bars)
      {
         try
         {
            _sharesMap.Clear();
            string filePath = @"C:\Trading\Aktienanzahl.txt";
            if (File.Exists(filePath))
            {
               string[] lines = File.ReadAllLines(filePath);
               foreach (string line in lines)
               {
                  string[] parts = line.Split(new char[] { ';', ',', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                  if (parts.Length >= 2)
                  {
                     string sym = parts[0].Trim().ToUpper();
                     if (Double.TryParse(parts[parts.Length - 1], NumberStyles.Any, CultureInfo.InvariantCulture, out double qty))
                        _sharesMap[sym] = qty;
                  }
               }
            }
            WriteToDebugLog("1. INIT: " + _sharesMap.Count + " Aktien geladen.");
         }
         catch (Exception ex) { WriteToDebugLog("FEHLER INIT: " + ex.Message); }
      }

      public override void PreExecute(DateTime dt, List<BarHistory> participants)
      {
         try
         {
            List<KeyValuePair<string, double>> ranking = new List<KeyValuePair<string, double>>();
            foreach (BarHistory bh in participants)
            {
               if (_sharesMap.TryGetValue(bh.Symbol.ToUpper(), out double shares))
               {
                  int tIdx = GetCurrentIndex(bh);
                  if (tIdx >= 0)
                     ranking.Add(new KeyValuePair<string, double>(bh.Symbol.ToUpper(), bh.Close[tIdx] * shares));
               }
            }
            ranking.Sort((x, y) => y.Value.CompareTo(x.Value));
            _top5 = ranking.Take(5).Select(r => r.Key).ToList();

            // Wir loggen nur beim allerersten Balken des gesamten Backtests
            if (dt == participants[0].DateTimes[0])
               WriteToDebugLog("2. RANKING: Top 5 sind " + string.Join(",", _top5));
         }
         catch (Exception ex) { WriteToDebugLog("FEHLER PRE: " + ex.Message); }
      }

      public override void Execute(BarHistory bars, int idx)
      {
         string sym = bars.Symbol.ToUpper();
         bool isInTop5 = _top5.Contains(sym);
         Position pos = FindOpenPosition(bars);

         if (pos != null && !isInTop5)
         {
            ClosePosition(pos, OrderType.Market, 0, "Out");
         }
         else if (pos == null && isInTop5)
         {
            // SICHERHEIT: Erstmal starr 100 Stück, um Sizing-Fehler auszuschließen
            Transaction t = PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0);
            if (t != null) t.Quantity = 100;
         }
      }

      private Position FindOpenPosition(BarHistory bh)
      {
         foreach (Position p in OpenPositions)
            if (p.Symbol.Equals(bh.Symbol, StringComparison.OrdinalIgnoreCase)) return p;
         return null;
      }
   }
}

CODE:
string[] parts = line.Split(new char[] { ';', ',', '\t' }, StringSplitOptions.RemoveEmptyEntries);

CODE:
using WealthLab.Backtest;
using System;
using WealthLab.Core;
using System.Collections.Generic;
using WealthLab.Indicators;

namespace WealthScript8 
{
   public class MarketCapRotation : UserStrategyBase
   {
      public override void Execute(BarHistory bars, int idx)
      {
         // 1. Marktkapitalisierung als Serie berechnen (für das Plotten wichtig)
         TimeSeries sharesSeries = Fundamental.Series(bars, "shares_outstanding", true);
         TimeSeries mCapSeries = bars.Close * sharesSeries;

         // Fallback-Logik: Falls MarketCap 0 ist, nutzen wir Volumen
         if (Double.IsNaN(mCapSeries[idx]) || mCapSeries[idx] <= 0)
         {
            // Wir füllen den Wert manuell, falls die Fundamentaldaten fehlen
            mCapSeries[idx] = bars.Close[idx] * bars.Volume[idx];
         }

         // 2. Visualisierung (Syntax für WL8: TimeSeries, Name, Farbe, Pane)
         // Wir plotten nur einmal am Ende der Historie oder laufend
         PlotTimeSeries(mCapSeries, "MarketCap", "MCapPane", WLColor.Blue);

         double currentMCap = mCapSeries[idx];
         if (Double.IsNaN(currentMCap) || currentMCap <= 0) currentMCap = 0.001;

         Position pos = LastPosition;

         // Handelslogik
         if (pos == null || !pos.IsOpen)
         {
            Transaction t = PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, "Entry");
            t.Weight = currentMCap;
         }
         else
         {
            // 1% Hurdle zur Stabilisierung
            Transaction t = PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, "Hold");
            t.Weight = currentMCap * 1.01;
         }
      }
   }
}

CODE:
using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Indicators;

namespace WealthLabStrategies.PriceAction
{
    public class MarketCapRotation : UserStrategyBase
    {
        private TimeSeries _mCapSeries;

        public override void Initialize(BarHistory bars)
        {
            // 1. Marktkapitalisierung als Serie berechnen (für das Plotten wichtig)
            var sharesSeries = Fundamental.Series(bars, "shares_outstanding", true);
            _mCapSeries = bars.Close * sharesSeries;
        }

        public override void Execute(BarHistory bars, int idx)
        {
            // Fallback-Logik: Falls MarketCap 0 ist, nutzen wir Volumen
            if (double.IsNaN(_mCapSeries[idx]) || _mCapSeries[idx] <= 0)
            {
                // Wir füllen den Wert manuell, falls die Fundamentaldaten fehlen
                _mCapSeries[idx] = bars.Close[idx] * bars.Volume[idx];
            }

            // 2. Visualisierung (Syntax für WL8: TimeSeries, Name, Farbe, Pane)
            // Wir plotten nur einmal am Ende der Historie oder laufend
            PlotTimeSeries(_mCapSeries, "MarketCap", "MCapPane", WLColor.Blue);

            var currentMCap = _mCapSeries[idx];
            if (double.IsNaN(currentMCap) || currentMCap <= 0)
            {
                currentMCap = 0.001;
            }

            var pos = LastPosition;

            // Handelslogik
            if (pos is not {IsOpen: true})
            {
                var t = PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, "Entry");
                t.Weight = currentMCap;
            }
            else
            {
                // 1% Hurdle zur Stabilisierung
                var t = PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, "Hold");
                t.Weight = currentMCap * 1.01;
            }
        }
    }
}

QUOTE:
I have installed the "Fundamental" extension, but I still can't get a usable result.

QUOTE:
However, if I start the strategy on January 2, 2015, the system doesn't even begin buying until February 2021.