DIE ICM-Formel??

    • gsusin
      gsusin
      Bronze
      Dabei seit: 17.07.2006 Beiträge: 728
      Hi Spielerz!

      Also mit meinen lächerlichen Delphi-Programmierkenntnissen habe ich mich mal dran gemacht, einen ICM-Calculator zu machen. Lief auch nicht so schlecht, bis es darum ging die Wahrscheinlichkeiten für den dritten Platz auszurechnen. Ein Freund, der sowohl in Mathe als auch im Programmieren um Längen besser ist als ich konnte mir in Beidem helfen, aber nicht mein Problem lösen.
      Ich bin immernoch auf der Suche nach einer Formel, mit der sich die Wahrscheinlichkeit ausrechnen lässt, dass Spieler x den k.-ten Platz belegt.
      Die Probabilities für 1st und 2nd sind kein Problem gewesen, dank HoH Vol III:

      Variablen:
      n= Anzahl der Spieler
      g= Gesamtzahl der Chips
      cx= Anzahl der Chips von Spieler x
      pxm=Chance, dass Spieler x den m. Platz belegt


      Chance, dass Spieler 1 erster wird:
      p11=c1/g

      Chance, dass Spieler 1 zweiter wird:
      p12= (c1/(g-c2))*p21 + (c1/(g-c3))*p31 + (c1/(g-c4))*p41 + (c1/(g-c5))*p51 + ... + (c1/(g-cn))*pn1



      Die Formel wird aber immer länger und komplizierter, wenn es um den 3., 4., 5. ... Platz geht.

      Die Formeln habe ich aus HoH Vol III, Seite 261ff.

      Zum dritten Platz schreibt Action Dan folgendes:
      "Calculating the third-place probabilities uses the same idea, but requires more bookkeeping. There are 12 possibilities for the first- and second-place finishers ( A first, B second, then A first, C second, all the way to D first and C second.) For each of those 12 situations, two players remain in contention for third, and each has a chance proportional to his chips divided by the total number of chips held by the two remaining players. Each of the 12 cases contributes a probability of finishing third for the two remaining players. Total all the contributions over the 12 cases, and you have the third-place probabilities."

      Leider beinhaltet das Beispiel in seinem Buch in diesem Fall nur 4 Spieler. Will man die Wahrscheinlichkeit eines Spielers dritter zu werden mit 10 Spielern left ausrechnen, gibt es nicht 12 sondern 81 verschiedene Fälle.

      Naja ich habe das mal gemacht:

      code:
      gchips:= all chips in play
      p13:=
      //2 1st
      (c1/(gchips-c2-c3))*p21*p32+(c1/(gchips-c2-c4))*p21*p42+(c1/(gchips-c2-c5))*p21*p52+
      (c1/(gchips-c2-c6))*p21*p62+(c1/(gchips-c2-c7))*p21*p72+(c1/(gchips-c2-c8))*p21*p82+
      (c1/(gchips-c2-c9))*p21*p92+(c1/(gchips-c2-c10))*p21*p102+
      //3 1st
      (c1/(gchips-c3-c2))*p31*p22+(c1/(gchips-c3-c4))*p31*p42+(c1/(gchips-c3-c5))*p31*p52+
      (c1/(gchips-c3-c6))*p31*p62+(c1/(gchips-c3-c7))*p31*p72+(c1/(gchips-c3-c8))*p31*p82+
      (c1/(gchips-c3-c9))*p31*p92+(c1/(gchips-c3-c10))*p31*p102+
      //4 1st
      (c1/(gchips-c4-c2))*p41*p22+(c1/(gchips-c4-c3))*p41*p32+(c1/(gchips-c4-c5))*p41*p52+
      (c1/(gchips-c4-c6))*p41*p62+(c1/(gchips-c4-c7))*p41*p72+(c1/(gchips-c4-c8))*p41*p82+
      (c1/(gchips-c4-c9))*p41*p92+(c1/(gchips-c4-c10))*p41*p102+
      //5 1st
      (c1/(gchips-c5-c2))*p51*p22+(c1/(gchips-c5-c3))*p51*p32+(c1/(gchips-c5-c4))*p51*p42+
      (c1/(gchips-c5-c6))*p51*p62+(c1/(gchips-c5-c7))*p51*p72+(c1/(gchips-c5-c8))*p51*p82+
      (c1/(gchips-c5-c9))*p51*p92+(c1/(gchips-c5-c10))*p51*p102+
      //6 1st
      (c1/(gchips-c6-c2))*p61*p22+(c1/(gchips-c6-c3))*p61*p32+(c1/(gchips-c6-c4))*p61*p42+
      (c1/(gchips-c6-c5))*p61*p52+(c1/(gchips-c6-c7))*p61*p72+(c1/(gchips-c6-c8))*p61*p82+
      (c1/(gchips-c6-c9))*p61*p92+(c1/(gchips-c6-c10))*p61*p102+
      //7 1st
      (c1/(gchips-c7-c2))*p71*p22+(c1/(gchips-c7-c3))*p71*p32+(c1/(gchips-c7-c4))*p71*p42+
      (c1/(gchips-c7-c5))*p71*p52+(c1/(gchips-c7-c6))*p71*p62+(c1/(gchips-c7-c8))*p71*p82+
      (c1/(gchips-c7-c9))*p71*p92+(c1/(gchips-c7-c10))*p71*p102+
      //8 1st
      (c1/(gchips-c8-c2))*p81*p22+(c1/(gchips-c8-c3))*p81*p32+(c1/(gchips-c8-c4))*p81*p42+
      (c1/(gchips-c8-c5))*p81*p52+(c1/(gchips-c8-c6))*p81*p62+(c1/(gchips-c8-c7))*p81*p72+
      (c1/(gchips-c8-c9))*p81*p92+(c1/(gchips-c8-c10))*p81*p102+
      //9 1st
      (c1/(gchips-c9-c2))*p91*p22+(c1/(gchips-c9-c3))*p91*p32+(c1/(gchips-c9-c4))*p91*p42+
      (c1/(gchips-c9-c5))*p91*p52+(c1/(gchips-c9-c6))*p91*p62+(c1/(gchips-c9-c7))*p91*p72+
      (c1/(gchips-c9-c8))*p91*p82+(c1/(gchips-c9-c10))*p91*p102+
      //10 1st
      (c1/(gchips-c10-c2))*p101*p22+(c1/(gchips-c10-c3))*p101*p32+(c1/(gchips-c10-c4))*p101*p42+
      (c1/(gchips-c10-c5))*p101*p52+(c1/(gchips-c10-c6))*p101*p62+(c1/(gchips-c10-c7))*p101*p72+
      (c1/(gchips-c10-c8))*p101*p82+(c1/(gchips-c10-c9))*p101*p92;
      


      Wiegesagt ein Freund hat es dann geschafft eine allgemeine Formel zu finden, mit der sich die Wahrscheinlichkeit dass Spieler x den k.-ten Platz belegt eigentlich ausrechnen lässt.



      cp und Ek(x) sind richtig, da bin ich mir sicher. (Mit Ek(x) wird die Equity ausgerechnet). Aber mit Fk(x) für k>1 gibt es Probleme.

      Denn beim 3rd Place bekomme ich andere Ergebnisse als Harrington in seinem Beispiel (Seite 260).
      Also habe ich es mit einem Online ICM-Calculator ausprobiert und ironischerweise nochmal andere Zahlen rausbekommen:
      http://www.poker-tools-online.com/icm.html
      http://www.chillin411.com/icmcalc.php

      Auf http://sharnett.bol.ucla.edu/ICM/info.html gibt es "an excellent discussion on how this model works, the history, it's limtitations and source code".
      Dummerweise offline.
      Auch in den 2+2 Foren und per Google habe ich die Formel nicht gefunden.
      Darum frage ich nun hier nach:

      Kennt jemand die allgemeine Formel mit der man die Probabilities ausrechnen kann, oder zumindest die für den dritten Platz?

      Ich hoffe mir kann jemand helfen, denn wenn das Programm das von mir geschrieben und von meinem Freund verbessert wurde erstmal funktioniert, dann wird es wahrscheinlich auch hier öffentlich gemacht.

      Beste Grüße,
      gsus
  • 10 Antworten
    • HoRRoR
      HoRRoR
      Black
      Dabei seit: 11.02.2005 Beiträge: 10.656
      sry bin grad nur ganz kurz drin und les mir nicht alles durch, vl heut abend

      aber ja, desto weiter der platz vom 1. platz entfernt ist, desto länger dauert die rechnung, das ganze wächst halt exponential glaub ich scho fast, d.h. nen 8. platz ausrechnen dauert ewig im vergleich zu ner rechnung für den 2.

      das gute ist nur, dass wenn man den 7. platz ausrechnet hat, hat man schon zwischenergebnisse für den 8. ;)
    • gsusin
      gsusin
      Bronze
      Dabei seit: 17.07.2006 Beiträge: 728
      Falls das für jemanden ne Hilfe ist, hier mal die vom Kumpel erarbeitete Formel in Visual Basic 6 geschrieben:
      code:
      Private Function GetProbability(ByVal players As Long, ByVal player As Long, stacks() As Long, ByVal prob As Long) As Double
      Dim i As Long
      Dim dblResult As Double
      If prob = 1 Then
      GetProbability = stacks(player) / m_lngChipCount
      ElseIf prob > 1 Then
      GetProbability = GetProbabilityK(players, player, stacks, probabs, prob)
      End If
      End Function
      
      Private Function GetProbabilityK(ByVal players As Long, ByVal player As Long, stacks() As Long, ByVal probs As Long) As Double
      Dim lngCounters() As Long
      Dim i As Long
      Dim j As Long
      Dim dblDiv As Double
      Dim dblResult As Double
      Dim blnIsDifferent As Boolean
      ReDim lngCounters(1 To probs - 1) As Long
      Do
      blnIsDifferent = True
      For i = 1 To probs - 1
      For j = 1 To probs - 1
      If i <> j Then
      blnIsDifferent = blnIsDifferent And (lngCounters(i) <> lngCounters(j))
      End If
      Next
      blnIsDifferent = blnIsDifferent And (lngCounters(i) <> player)
      Next
      If blnIsDifferent Then
      dblDiv = m_lngChipCount
      For i = 1 To probs - 1
      dblDiv = dblDiv - stacks(lngCounters(i))
      Next
      If dblDiv <> 0 Then
      dblDiv = stacks(player) / dblDiv
      End If
      For i = 1 To probs - 1
      dblDiv = dblDiv * GetProbability(players, lngCounters(i), stacks, i)
      Next
      dblResult = dblResult + dblDiv
      End If
      lngCounters(probs - 1) = lngCounters(probs - 1) + 1
      For i = probs - 1 To 1 Step -1
      If lngCounters(i) = players Then
      If i = 1 Then
      Exit Do
      Else
      lngCounters(i - 1) = lngCounters(i - 1) + 1
      lngCounters(i) = 0
      End If
      End If
      Next
      Loop
      GetProbabilityK = dblResult
      End Function
      
    • gr8ermoon
      gr8ermoon
      Bronze
      Dabei seit: 05.09.2006 Beiträge: 37
      Traust du diesen ICM Calculators nicht?
      ICM Calc 1
      ICM Calc 2
    • gsusin
      gsusin
      Bronze
      Dabei seit: 17.07.2006 Beiträge: 728
      du hast doch nichtmal ein viertel von meinem beitrag gelesen, oder?
      die beiden icm calc's hab ich auch verlinkt, mir gehts aber um die formel und nicht um ergebnisse bzw vertrauen. würde es schon einen icm calc geben, bei dem die anzahl der player sowie icm plätze frei wählbar sind, würde ich mir die mühen garnicht machen.
    • HoRRoR
      HoRRoR
      Black
      Dabei seit: 11.02.2005 Beiträge: 10.656
      spade icm hat so etwas integriert ;)
    • gsusin
      gsusin
      Bronze
      Dabei seit: 17.07.2006 Beiträge: 728
      trial abgelaufen, alle möglichen registry-keys gelöscht, die sind zu smart :(
    • McIllroy
      McIllroy
      Bronze
      Dabei seit: 29.10.2006 Beiträge: 606
      schon mal an kaufen gedacht?^^
    • Mr.Snood
      Mr.Snood
      Bronze
      Dabei seit: 22.01.2005 Beiträge: 5.352
      Dabei ist kaufen sogar billiger als selbst programmieren.
      Es sei denn, mehrere Stunden programmieren und über die Formal nachdenken stellen für dich keinen Aufwand dar :P
    • dvrvm
      dvrvm
      Bronze
      Dabei seit: 31.01.2007 Beiträge: 3.956
      Bei mir sah das in C# mal so aus (und funktionierte):
      code:
      using System;
      using System.Collections.Generic;
      using System.Text;
      
      namespace ICM
      {
          public class Player
          {
              public int Stack;
              public double[] Pnth;
      
              public double DollarEV(double[] Payout)
              {
                  double TDEV = 0;
                  int Length = Payout.Length;
                  if (Pnth.Length < Payout.Length)
                      Length = Pnth.Length;
                  for (int Cnt = 0; Cnt < Length; Cnt++)
                  {
                      TDEV += Pnth[Cnt] * Payout[Cnt]; 
                  }
                  return TDEV;
              }
      
              public Player(int Stack, int Payouts)
              {
                  Pnth = new double[Payouts];
                  this.Stack = Stack;
              }
          }
      }
      
      code:
      using System;
      using System.Collections.Generic;
      using System.Text;
      
      namespace ICM
      {
          public class ProbTree
          {
              //public static double[] Payout;
              public static int Levels;
      
              static ProbTree()
              {
                  //Payout = new double[] { 0.5, 0.3, 0.2 };
                  Levels = 3;
              }
      
              int Level; // zero-based (1th: level 0, 2th: level 1...)
              double Pcase;
              List<Player> Stacks;
      
              public ProbTree(double Pcase, List<Player> players, int Level) : base()
              {
                  this.Pcase = Pcase;
                  Stacks = new List<Player>(players);
                  this.Level = Level;
              }
      
              public void EvalSubtree()
              {
                  int CompleteStack = 0;
                  foreach(Player player in Stacks)
                      CompleteStack += player.Stack;
                  List<Player> NuStacks = new List<Player>(Stacks);
                  foreach (Player player in Stacks)
                  {
                      double Pthiscase = (double)player.Stack / (double)CompleteStack * Pcase;
                      player.Pnth[Level] += Pthiscase;
                      if (Level < (Levels-1))
                      {
                          NuStacks.Remove(player);
                          ProbTree subtree = new ProbTree(Pthiscase, NuStacks, Level + 1);
                          subtree.EvalSubtree();
                          NuStacks.Add(player);
                      }
                  }
              } // EvalSubtree
          } // class
      }
      
    • JuliCash
      JuliCash
      Bronze
      Dabei seit: 31.07.2006 Beiträge: 946
      Hab diese mal mit copy&Paste gemacht.

      Ein Heidn-Aufwand.

      Ne allgemeine Formel hab ich nicht hingrkriegt. Ich weiß nicht ob das funktioniert. (Hab meine mal versucht in Derrive zu vereinfachen, ging aber nix)

      Das Sind nur die Wahrscheinlichkeit für 3 Spieler. (Bei insges. 6, denke das reicht oder?), war dann zu faul weiterzumachen

      P1_3:

      (S2/Sges)*(S3/(Sges-S2))*(S1/(Sges-S2-S3))
      +(S2/Sges)*(S4/(Sges-S2))*(S1/(Sges-S2-S4))
      +(S2/Sges)*(S5/(Sges-S2))*(S1/(Sges-S2-S5))
      +(S2/Sges)*(S6/(Sges-S2))*(S1/(Sges-S2-S6))

      +(S3/Sges)*(S2/(Sges-S3))*(S1/(Sges-S3-S2))
      +(S3/Sges)*(S4/(Sges-S3))*(S1/(Sges-S3-S4))
      +(S3/Sges)*(S5/(Sges-S3))*(S1/(Sges-S3-S5))
      +(S3/Sges)*(S6/(Sges-S3))*(S1/(Sges-S3-S6))

      +(S4/Sges)*(S2/(Sges-S4))*(S1/(Sges-S4-S2))
      +(S4/Sges)*(S3/(Sges-S4))*(S1/(Sges-S4-S3))
      +(S4/Sges)*(S5/(Sges-S4))*(S1/(Sges-S4-S5))
      +(S4/Sges)*(S6/(Sges-S4))*(S1/(Sges-S4-S6))

      +(S5/Sges)*(S2/(Sges-S5))*(S1/(Sges-S5-S2))
      +(S5/Sges)*(S3/(Sges-S5))*(S1/(Sges-S5-S3))
      +(S5/Sges)*(S4/(Sges-S5))*(S1/(Sges-S5-S4))
      +(S5/Sges)*(S6/(Sges-S5))*(S1/(Sges-S5-S6))

      +(S6/Sges)*(S2/(Sges-S6))*(S1/(Sges-S6-S2))
      +(S6/Sges)*(S3/(Sges-S6))*(S1/(Sges-S6-S3))
      +(S6/Sges)*(S4/(Sges-S6))*(S1/(Sges-S6-S4))
      +(S6/Sges)*(S5/(Sges-S6))*(S1/(Sges-S6-S5))

      P2_3

      (S1/Sges)*(S3/(Sges-S1))*(S2/(Sges-S1-S3))
      +(S1/Sges)*(S4/(Sges-S1))*(S2/(Sges-S1-S4))
      +(S1/Sges)*(S5/(Sges-S1))*(S2/(Sges-S1-S5))
      +(S1/Sges)*(S6/(Sges-S1))*(S2/(Sges-S1-S6))

      +(S3/Sges)*(S1/(Sges-S3))*(S2/(Sges-S3-S1))
      +(S3/Sges)*(S4/(Sges-S3))*(S2/(Sges-S3-S4))
      +(S3/Sges)*(S5/(Sges-S3))*(S2/(Sges-S3-S5))
      +(S3/Sges)*(S6/(Sges-S3))*(S2/(Sges-S3-S6))

      +(S4/Sges)*(S1/(Sges-S4))*(S2/(Sges-S4-S1))
      +(S4/Sges)*(S3/(Sges-S4))*(S2/(Sges-S4-S3))
      +(S4/Sges)*(S5/(Sges-S4))*(S2/(Sges-S4-S5))
      +(S4/Sges)*(S6/(Sges-S4))*(S2/(Sges-S4-S6))

      +(S5/Sges)*(S1/(Sges-S5))*(S2/(Sges-S5-S1))
      +(S5/Sges)*(S3/(Sges-S5))*(S2/(Sges-S5-S3))
      +(S5/Sges)*(S4/(Sges-S5))*(S2/(Sges-S5-S4))
      +(S5/Sges)*(S6/(Sges-S5))*(S2/(Sges-S5-S6))

      +(S6/Sges)*(S1/(Sges-S6))*(S2/(Sges-S6-S1))
      +(S6/Sges)*(S3/(Sges-S6))*(S2/(Sges-S6-S3))
      +(S6/Sges)*(S4/(Sges-S6))*(S2/(Sges-S6-S4))
      +(S6/Sges)*(S5/(Sges-S6))*(S2/(Sges-S6-S5))

      P3_3:

      (S1/Sges)*(S2/(Sges-S1))*(S3/(Sges-S1-S2))
      +(S1/Sges)*(S4/(Sges-S1))*(S3/(Sges-S1-S4))
      +(S1/Sges)*(S5/(Sges-S1))*(S3/(Sges-S1-S5))
      +(S1/Sges)*(S6/(Sges-S1))*(S3/(Sges-S1-S6))

      +(S2/Sges)*(S1/(Sges-S2))*(S3/(Sges-S2-S1))
      +(S2/Sges)*(S4/(Sges-S2))*(S3/(Sges-S2-S4))
      +(S2/Sges)*(S5/(Sges-S2))*(S3/(Sges-S2-S5))
      +(S2/Sges)*(S6/(Sges-S2))*(S3/(Sges-S2-S6))

      +(S4/Sges)*(S1/(Sges-S4))*(S3/(Sges-S4-S1))
      +(S4/Sges)*(S2/(Sges-S4))*(S3/(Sges-S4-S2))
      +(S4/Sges)*(S5/(Sges-S4))*(S3/(Sges-S4-S5))
      +(S4/Sges)*(S6/(Sges-S4))*(S3/(Sges-S4-S6))

      +(S5/Sges)*(S1/(Sges-S5))*(S3/(Sges-S5-S1))
      +(S5/Sges)*(S2/(Sges-S5))*(S3/(Sges-S5-S2))
      +(S5/Sges)*(S4/(Sges-S5))*(S3/(Sges-S5-S4))
      +(S5/Sges)*(S6/(Sges-S5))*(S3/(Sges-S5-S6))

      +(S6/Sges)*(S1/(Sges-S6))*(S3/(Sges-S6-S1))
      +(S6/Sges)*(S3/(Sges-S6))*(S3/(Sges-S6-S3))
      +(S6/Sges)*(S4/(Sges-S6))*(S3/(Sges-S6-S4))
      +(S6/Sges)*(S5/(Sges-S6))*(S3/(Sges-S6-S5))