Sorry for the delay, I got a small cold. I'm answering PM's and coding a couple releases at snail speed, but chances are I won't write too much new material.


Will try to bring in some of the "oldies but good" topics around.




Hope to be fresh as lettuce in some days. Got a fresh supply of Vitamin C    as well as eating fruits.

Wonderful! A single thread for Clumping Theory. Thanks for bringing it to the fore dear Richard.

---

I want to write a bit about 'Signal strength':

Whatever the bet, there will typically be a part on the wheel where it will succeed more. i.e. if you are using "neighbors" as a bet, there will be a side where the "neighbor hit" event is striking in a greater frequency, it is there where the "signal" is more powerful, where it has more strength; therefore you use it to narrow the area of clumping for such event, helping you when pondering where to focus your attack.

This easily seen in practice when being in front of a disc. Look at the following areas with 3 realized neighbors each:

[attachimg=1]

Zone 27 to 24 has 3 realized neighbors (in blue)

Zone 12 to 4 has 3 realized neighbors too (in red)

We say the signal is stronger in zone 12 to 4 because the events are being realized with a better clumping. The realization of an even in larger areas "dilutes" the signal, the same realization in shorter areas makes it stronger. We back up where it's stronger.

Number 0 would bring '4 realized neighbors' within an area of 9.

Number 17 would bring '4 realized neighbors' within an area of 13.

...hence number 0 would be given more weight when considering neighbor bets over number 17.

Quote from: albalaha on January 15, 2013, 03:40:06 PM10% of the sale proceeds or rent of bot will go to this Forum's upkeep.

Thank you dear Sumit.
That would be VERY appreciated 

[attachimg=1]

[attachimg=2]

http://en.wikipedia.org/wiki/Roulette_Township,_Potter_County,_Pennsylvania

A whole township of roulette people!

Quote from: esoito on January 15, 2013, 03:35:07 AM
"I'll give it a couple more days and then perhaps take it off-line."

@Bryan

A good idea to leave it.

+1

It's always a good idea to leave the door open for future contributions. I've been gotten activity (forum/email) for messages from YEARS past. It happens and can be fulfilling. It costs nothing to leave it there for fellow readers in the future 

Source:
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Xml;
using System.Xml.XPath;


namespace LastXSplits_0_1
{
    public partial class Form1 : Form
    {
        /// <summary>
        /// Constructor
        /// </summary>
        public Form1()
        {
            // Initialization
            InitializeComponent();
        }


        // History implemented as stack (LIFO)
        Stack<int> history = new Stack<int>();


        // Redo implemented as stack too
        Stack<int> redo = new Stack<int>();


        // Splits as List of Split class
        List<Split> Splits = new List<Split>() { new Split(1, 0), new Split(2, 0), new Split(3, 0), new Split(1, 2), new Split(1, 4), new Split(2, 3), new Split(2, 5), new Split(3, 6), new Split(4, 5), new Split(4, 7), new Split(5, 6), new Split(5,, new Split(6, 9), new Split(7,, new Split(7, 10), new Split(8, 9), new Split(8, 11), new Split(9, 12), new Split(10, 11), new Split(10, 13), new Split(11, 12), new Split(11, 14), new Split(12, 15), new Split(13, 14), new Split(13, 16), new Split(14, 15), new Split(14, 17), new Split(15, 18), new Split(16, 17), new Split(16, 19), new Split(17, 18), new Split(17, 20), new Split(18, 21), new Split(19, 20), new Split(19, 22), new Split(20, 21), new Split(20, 23), new Split(21, 24), new Split(22, 23), new Split(22, 25), new Split(23, 24), new Split(23, 26), new Split(24, 27), new Split(25, 26), new Split(25, 28), new Split(26, 27), new Split(26, 29), new Split(27, 30), new Split(28, 29), new Split(28, 31), new Split(29, 30), new Split(29, 32), new Split(30, 33), new Split(31, 32), new Split(31, 34), new Split(32, 33), new Split(32, 35), new Split(33, 36), new Split(34, 35), new Split(35, 36) };


        // Counter as BindingList of SplitCount (bound to DataGridView in FormCount)
        BindingList<SplitCount> Counter = new BindingList<SplitCount>();
       
        // Instantiate history form
        Form fHistory = new FormHistory();


        // Instantiate counter form
        Form fCount = new FormCount();


        // Reference to DataGridView
        DataGridView dgvCount;


        // Reference to History ListBox
        ListBox lbHistory;


        // Global PictureBox Array
        PictureBox[] pbG;


        // XML settings Filename
        string xmlFile = Path.GetDirectoryName(Application.ExecutablePath) + "\\LastXSplits.xml";


        /// <summary>
        /// Program's entrypoint
        /// </summary>
        private void Form1_Load(object sender, EventArgs e)
        {
            // Declare control array
            PictureBox[] pbCtrl = { pb0, pb1, pb2, pb3, pb4, pb5, pb6, pb7, pb8, pb9, pb10, pb11, pb12, pb13, pb14, pb15, pb16, pb17, pb18, pb19, pb20, pb21, pb22, pb23, pb24, pb25, pb26, pb27, pb28, pb29, pb30, pb31, pb32, pb33, pb34, pb35, pb36 };


            // Assign references
            pbG = pbCtrl;


            // Attach events to each control
            foreach (PictureBox ctrl in pbCtrl)
            {
                // MouseLeave
                ctrl.MouseLeave += new EventHandler(PictureBox_MouseLeave);


                // MouseEnter
                ctrl.MouseEnter += new EventHandler(PictureBox_MouseEnter);


                // MouseDown
                ctrl.MouseDown += new MouseEventHandler(PictureBox_MouseDown);


                // MouseUp
                ctrl.MouseUp += new MouseEventHandler(PictureBox_MouseUp);


                // MouseClick
                ctrl.MouseClick += new MouseEventHandler(PictureBox_MouseClick);
            }


            // Set dgvCount
            dgvCount = (DataGridView)fCount.Controls["dgvCount"];


            // Prevent automatic generation of columns
            dgvCount.AutoGenerateColumns = false;


            // Add shows column
            DataGridViewTextBoxColumn showsColumn = new DataGridViewTextBoxColumn();
            showsColumn.DataPropertyName = "Shows";
            showsColumn.HeaderText = "Shows";
            showsColumn.Width = 50;
            showsColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
            showsColumn.DefaultCellStyle.Font = new Font(fileToolStripMenuItem.Font, fileToolStripMenuItem.Font.Style ^ FontStyle.Italic);
            dgvCount.Columns.Add(showsColumn);


            // Add splits column
            DataGridViewTextBoxColumn splitsColumn = new DataGridViewTextBoxColumn();
            splitsColumn.DataPropertyName = "Splits";
            splitsColumn.HeaderText = "Splits";
            showsColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
            splitsColumn.DefaultCellStyle.Font = new Font(fileToolStripMenuItem.Font, fileToolStripMenuItem.Font.Style ^ FontStyle.Italic);
            splitsColumn.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
            dgvCount.Columns.Add(splitsColumn);


            // Set dgvCount DataSource
            dgvCount.DataSource = Counter;


            // Set lbHistory
            lbHistory = (ListBox)fHistory.Controls["lbHistory"];


            // Show history form
            fHistory.Show();


            // Show counters form
            fCount.Show();


            // Check for XML file
            if (File.Exists(xmlFile))
            {
                // Set XPath Document               
                XPathDocument document = new XPathDocument(xmlFile);


                // Create XPath Navigator
                XPathNavigator navigator = document.CreateNavigator();


                // Process Options
                foreach (XPathNavigator section in navigator.Select("/LastXSplits/Options"))
                {
                    foreach (XPathNavigator node in section.SelectChildren(XPathNodeType.All))
                    {
                        // Toggle options
                        foreach (ToolStripMenuItem tsmi in optionsToolStripMenuItem.DropDownItems)
                        {
                            // Set CheckState
                            if (tsmi.Name == node.Name + "ToolStripMenuItem")
                            {
                                // Load from file
                                tsmi.CheckState = (node.InnerXml == "Checked" ? CheckState.Checked : CheckState.Unchecked);
                            }
                        }
                    }
                }


                // Coordinates
                if (saveCoordinatesToolStripMenuItem.Checked)
                {
                    // Process
                    foreach (XPathNavigator section in navigator.Select("/LastXSplits/Coordinates"))
                    {
                        foreach (XPathNavigator subsection in section.SelectChildren(XPathNodeType.All))
                        {
                            // Process forms
                            foreach (Form frm in Application.OpenForms)
                            {
                                // Match
                                if (frm.Name == subsection.Name)
                                {
                                    // Set X,Y
                                    foreach (XPathNavigator node in subsection.SelectChildren(XPathNodeType.All))
                                    {
                                        // X
                                        if (node.Name == "x")
                                        {
                                            frm.Left = Convert.ToInt32(node.InnerXml);
                                        }


                                        // Y
                                        if (node.Name == "y")
                                        {
                                            frm.Top = Convert.ToInt32(node.InnerXml);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }


                // Last X value
                if (saveXToolStripMenuItem.Checked)
                {
                    // Set X
                    nudX.Value = Convert.ToInt32(navigator.SelectSingleNode("/LastXSplits/LastX/X").InnerXml);
                }
            }
            else
            {
                // Default options check state
                topmostToolStripMenuItem.Checked = true;
                saveCoordinatesToolStripMenuItem.Checked = true;
                saveXToolStripMenuItem.Checked = true;


                // Default "X"
                nudX.Value = 18;
            }
        }


        /// <summary>
        /// MouseEnter handler
        /// </summary>
        private void PictureBox_MouseEnter(object sender, System.EventArgs e)
        {
            // Show alpha-blended image
            ((PictureBox)sender).BackgroundImage = Properties.Resources.yellow_highlight_alpha_38x47;
        }


        /// <summary>
        /// MouseLeave handler
        /// </summary>
        private void PictureBox_MouseLeave(object sender, System.EventArgs e)
        {
            // Remove image
            ((PictureBox)sender).BackgroundImage = null;
        }


        /// <summary>
        /// MouseDown Handler
        /// </summary>
        private void PictureBox_MouseDown(object sender, MouseEventArgs e)
        {
            // Check for left button
            if (e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                // Change cursor to hand
                ((PictureBox)sender).Cursor = Cursors.Hand;


                // Show blue alpha-blended image
                ((PictureBox)sender).BackgroundImage = Properties.Resources.blue_highlight_alpha_38x47;
            }
        }


        /// <summary>
        /// MouseUp Handler
        /// </summary>
        private void PictureBox_MouseUp(object sender, MouseEventArgs e)
        {
            // Show yellow alpha-blended image
            ((PictureBox)sender).BackgroundImage = Properties.Resources.yellow_highlight_alpha_38x47;


            // Change cursor back
            ((PictureBox)sender).Cursor = Cursors.Default;
        }


        /// <summary>
        /// MouseClick handler
        /// </summary>
        private void PictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            /* Right click = UNDO */


            if (e.Button == System.Windows.Forms.MouseButtons.Right)
            {
                // Check there's history
                if (history.Count > 0)
                {
                    // Pop last one
                    history.Pop();


                    // Remove from history ListBox
                    lbHistory.Items.RemoveAt(0);
                }


                // Disable if no history
                if (history.Count == 0)
                {
                    // Disable
                    disable();
                }


                // Update
                update();


                // Halt flow
                return;
            }


            // Check sender
            if (!(sender is PictureBox))
            {
                // Halt flow too
                return;
            }


            /* Left click = add to history */


            // Snip number
            int number = Convert.ToInt32(((PictureBox)sender).Name.ToString().Substring(2));


            // Push onto history stack
            history.Push(number);


            // Add to history ListBox
            lbHistory.Items.Insert(0, number);


            // Enable on first item
            if (history.Count == 1)
            {
                enable();
            }


            // Disable redo if manual input
            if (redo.Count > 0 && e.Delta != 1)
            {
                // Reset stack
                redo.Clear();
               
                // Disable
                redoToolStripMenuItem.Enabled = false;
            }


            // Update
            update();
        }


        /// <summary>
        /// Disable MenuItem group
        /// </summary>
        private void disable()
        {
            // Disable undo
            undoToolStripMenuItem.Enabled = false;


            // Disable new
            newToolStripMenuItem.Enabled = false;


            // Disable save spins
            saveToolStripMenuItem.Enabled = false;
        }


        /// <summary>
        /// Enable MenuItem group
        /// </summary>
        private void enable()
        {
            // Enable undo
            undoToolStripMenuItem.Enabled = true;


            // Enable new
            newToolStripMenuItem.Enabled = true;


            // Enable save spins
            saveToolStripMenuItem.Enabled = true;
        }


        /// <summary>
        /// Update procedure
        /// </summary>
        private void update()
        {
            // Set dictionary of int, List<Split>
            Dictionary<int, List<Split>> SpD = new Dictionary<int, List<Split>>();


            // Reset every split counter
            foreach (Split sp in Splits)
            {
                // Zero it
                sp.count = 0;
            }


            // Set a count for iterations
            int iteration = 0;


            // Update X times
            foreach (int currentNumber in history)
            {
                // Rise iteration count
                ++iteration;


                // Update Splits list count
                foreach (Split sp in Splits)
                {
                    // If number in split matches input one
                    if (sp.n1 == currentNumber || sp.n2 == currentNumber)
                    {
                        // Rise one in .count
                        sp.count += 1;
                    }
                }


                // Check if must halt
                if (iteration == nudX.Value)
                {
                    // Time to break
                    break;
                }
            }


            // Set dictionary values
            foreach (Split sp in Splits)
            {
                // Account (or not) for unhit splits
                if (sp.count == 0 && !showUnhitSplitsToolStripMenuItem.Checked)
                {
                    // Unchecked, skip iteration
                    continue;
                }


                // Create dictionary entry if not present
                if (!SpD.ContainsKey(sp.count))
                {
                    // Add new list
                    SpD.Add(sp.count, new List<Split>() { sp });
                }
                else
                {
                    // Add split to index
                    SpD[sp.count].Add(sp);
                }
            }


            // Clear counter
            Counter.Clear();


            // Declare new int list
            List<int> intList = new List<int>();


            // Populate with dictionary keys
            foreach (KeyValuePair<int, List<Split>> kvp in SpD)
            {
                // Add key to list
                intList.Add(kvp.Key);
            }


            // Sort list
            intList.Sort();


            // Sync counter with dictionary using list
            for (int i = 0; i < intList.Count; ++i)
            {
                // Add to Counter
                Counter.Add(new SplitCount(intList[i], SpD[intList[i]]));
            }


            // Update status strip count
            tsslHistory.Text = history.Count.ToString();
        }


        /// <summary>
        /// Launch website in default browser
        /// </summary>
        private void websiteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Open web
            LaunchSite();
        }


        /// <summary>
        /// Open website in default browser
        /// </summary>
        private void LaunchSite()
        {
            // Launch BetSelection.cc
            System.Diagnostics.Process.Start("http://betselection.cc");
        }


        /// <summary>
        /// Show about box
        /// </summary>
        private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Message
            MessageBox.Show("Sponsored by WannaWin for the BetSelection.cc community." + Environment.NewLine + Environment.NewLine + "Coded by: Victor/VLS" + Environment.NewLine + Environment.NewLine + "Point your browser to [url=http://www.BetSelection.cc]www.BetSelection.cc[/url] for more releases!" + Environment.NewLine + Environment.NewLine + "(January 2013)", "About Last X Splits", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
        }


        /// <summary>
        /// Account for unhit splits
        /// </summary>
        private void showUnhitSplitsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Reverse checked status
            showUnhitSplitsToolStripMenuItem.Checked = !showUnhitSplitsToolStripMenuItem.Checked;


            // Perform an update
            update();
        }


        /// <summary>
        /// Act upon change of X
        /// </summary>
        private void nudX_ValueChanged(object sender, EventArgs e)
        {
            // Trigger update
            update();
        }


        /// <summary>
        /// Launch website when form is closed
        /// </summary>
        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Open web
            LaunchSite();
        }


        /// <summary>
        /// Save XMl file right before closing
        /// </summary>
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // Check for confirmation
            if (confirmOnExitToolStripMenuItem.Checked)
            {
                // Prompt user
                if (MessageBox.Show("Exit the program now?", "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.No)
                {
                    // Cancel form close
                    e.Cancel = true;


                    // Exit procedure
                    return;
                }
            }


            // Instantiate XmlTextWriter
            XmlTextWriter writer = new XmlTextWriter(xmlFile, null);


            // Set formatting
            writer.Formatting = Formatting.Indented;
            writer.Indentation = 4;


            // Document start
            writer.WriteStartDocument();


            // Root start
            writer.WriteStartElement("LastXSplits");


            // Options start
            writer.WriteStartElement("Options");


            // Write options
            foreach (ToolStripMenuItem tsmi in optionsToolStripMenuItem.DropDownItems)
            {
                // Save checked status
                writer.WriteElementString(tsmi.Name.Replace("ToolStripMenuItem", ""), tsmi.CheckState.ToString());
            }


            // Options end
            writer.WriteEndElement();


            // Coordinates start
            writer.WriteStartElement("Coordinates");


            // Iterate through forms
            foreach (Form frm in Application.OpenForms)
            {
                // Current form start
                writer.WriteStartElement(frm.Name);


                // Save coordinates
                writer.WriteElementString("x", frm.Left.ToString());
                writer.WriteElementString("y", frm.Top.ToString());


                // Current form end
                writer.WriteEndElement();
            }


            // Coordinates end
            writer.WriteEndElement();


            // LastX start
            writer.WriteStartElement("LastX");


            // X value
            writer.WriteElementString("X", nudX.Value.ToString());


            // LastX end
            writer.WriteEndElement();


            // Root start
            writer.WriteEndElement();


            // Document end
            writer.WriteEndDocument();


            // Close writer
            writer.Close();
        }


        /// <summary>
        /// TopMost for all forms
        /// </summary>
        private void topmostToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Reverse checked
            topmostToolStripMenuItem.Checked = !topmostToolStripMenuItem.Checked;


            // Set TopMost in forms
            this.TopMost = topmostToolStripMenuItem.Checked;
            fCount.TopMost = topmostToolStripMenuItem.Checked;
            fHistory.TopMost = topmostToolStripMenuItem.Checked;
        }


        /// <summary>
        /// Exit program by file menu
        /// </summary>
        private void exitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Close main form
            this.Close();
        }


        /// <summary>
        /// Toggles flag for saving coordinates
        /// </summary>
        private void saveCoordinatesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Reverse
            saveCoordinatesToolStripMenuItem.Checked = !saveCoordinatesToolStripMenuItem.Checked;
        }


        /// <summary>
        /// Toggles flag for saving X
        /// </summary>
        private void saveXToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Reverse
            saveXToolStripMenuItem.Checked = !saveXToolStripMenuItem.Checked;
        }


        /// <summary>
        /// Undo by menu
        /// </summary>
        private void undoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Add to undo stack
            redo.Push(history.Peek());


            // Trigger MouseClick
            PictureBox_MouseClick(sender, new MouseEventArgs(System.Windows.Forms.MouseButtons.Right, 1, 0, 0, 0));


            // Check redo menu state
            if (redoToolStripMenuItem.Enabled == false)
            {
                // Activate
                redoToolStripMenuItem.Enabled = true;
            }
        }


        /// <summary>
        /// Exit confirmation flag
        /// </summary>
        private void confirmOnExitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Reverse
            confirmOnExitToolStripMenuItem.Checked = !confirmOnExitToolStripMenuItem.Checked;
        }


        /// <summary>
        /// Start new session by menu
        /// </summary>
        private void newToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Reset history
            history.Clear();


            // Reset history listbox
            lbHistory.Items.Clear();


            // Perform an update
            update();


            // Disable menu items
            disable();
        }


        /// <summary>
        /// Save history sipns
        /// </summary>
        private void saveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Check there's something to save
            if (history.Count > 0)
            {
                // Instantiate SaveFileDialog
                SaveFileDialog sfd = new SaveFileDialog();


                // Set properties
                sfd.Filter = "Text Files|*.txt|All Files|*.*";
                sfd.Title = "Save an Image File";
               
                // Display dialog
                sfd.ShowDialog();


                // If there's a file
                if (sfd.FileName != "")
                {
                    // Stack enumerator
                    IEnumerator en = history.GetEnumerator();


                    // StringBuilder
                    StringBuilder sb = new StringBuilder();


                    // Transverse stack
                    while(en.MoveNext())
                    {
                        // Insert current with NewLine (for speed)
                        sb.Insert(0, en.Current.ToString() + Environment.NewLine);
                    }


                    // Remove last NewLine
                    sb.Remove(sb.ToString().LastIndexOf(Environment.NewLine), Environment.NewLine.Length);
                   
                    // Dump StringBuilder to file
                    File.WriteAllText(sfd.FileName, sb.ToString());
                }
            }
        }


        /// <summary>
        /// Redo menu
        /// </summary>
        private void redoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Perform click on last
            foreach (PictureBox pb in pbG)
            {
                // Check if names match
                if (redo.Peek() == Convert.ToInt32(pb.Name.Remove(0, 2)))
                {
                    // Match
                    PictureBox_MouseClick(pb, new MouseEventArgs(System.Windows.Forms.MouseButtons.Left, 1, 0, 0, 1));


                    // Break for
                    break;
                }
            }


            // Pop last item
            redo.Pop();
           
            // Check for items
            if (redo.Count == 0)
            {
                // Disable
                redoToolStripMenuItem.Enabled = false;
            }
        }
    }


    /// <summary>
    /// Split class
    /// </summary>
    public class Split
    {
        // Count, First and second splits
        public int count, n1, n2;


        // Overloaded constructor
        public Split(int first, int second)
        {
            // Set first number
            n1 = first;


            // Set second number
            n2 = second;
        }
    }


    /// <summary>
    /// SplitCount Class
    /// </summary>
    public class SplitCount
    {
        // Shows
        public int _shows;


        // Splits
        public List<Split> _splits;


        /// <summary>
        /// Overloaded constructor
        /// </summary>
        /// <param name="shows">int for shows</param>
        /// <param name="splits">List of Split</param>
        public SplitCount(int shows, List<Split> splits)
        {
            _shows = shows;
            _splits = splits;
        }


        /// <summary>
        /// Shows property
        /// </summary>
        public int Shows
        {
            get { return _shows; }
            set { _shows = value; }
        }


        /// <summary>
        /// Splits property
        /// </summary>
        public string Splits
        {
            get
            {
                // Splits string
                string splits = "";


                // Populate splits string
                foreach (Split sp in _splits)
                {
                    // First number + second number + comma and space (added after every split for speed)
                    splits += sp.n1 + "-" + sp.n2 + ", ";
                }


                // Strip last comma and space
                splits = splits.Substring(0, splits.Length - 2);


                // Return processed string
                return splits;
            }
        }
    }
}

Tracks all splits' shows within a window of spins (last "X").

Download: [attachmini=1]


[attachimg=2]


Enjoy!
Vic

Quote from: Drazen on January 14, 2013, 12:32:54 PM
Now my only worry is that Vic will start to recieve death threats

  I certainly hope it isn't the case! 

Quote from: JohnLegend on January 14, 2013, 01:10:30 PM
Thanks again Bayes. 10% of whatever I make from this and the other methods will be donated to Victor and the forum. So many will benefit from this.

That's quite kind dear John. Thank you VERY much.
It's reassuring to know there'll be your monthly help   

Quote from: XXVV on January 14, 2013, 05:18:03 PM
@Clumping Theory , ie sub set of Cluster Theory

One thing is to observe what is formed every 37-spin clusters (overall effect for the cycle), and another thing to study how they clump (pre-effect -but not cause!, It's the study of how the effect unfolds, the study of how a moving target starts to "move" and its properties such as direction, signal strength, etc. i.e. the study of the very moving condition(s)).

I'd say correlating it to the wheel as a physical object should be the very first choice to learn it.

More "ethereal" scenarios can be derived; but at first, having a physical object can help on comprehending it. i.e. a loaded area on the wheel is clearly related to the side where the ball strikes the most for current cycle, hence it's very easy to grasp.


Clumping Theory deserves its own thread   

That's all there is to quote. 

Feel free to continue the topic in here. 

Quote from: Maui13AWESOME ADVICE ....!!!!!   


Something I would like to add is "patience" - as I myself sometimes start rushing things, when my behind hurts because I've been sitting so long    and then things go pear shape!

Quote from: LuckyLucyHi Victor so I'm a semi pro! cool, not a random chip thrower!

to be honest I used to be, but probably because when I first started playing on live super casino, while the presenters don't take you by the hand and say, oh you should do this etc, they do go on about hot numbers/cold numbers, numbers on the carosel, there favourite numbers etc.  if you are not an experienced player, or drunk! then it can influence your descion making. They also try to encourage you (a lot) to take the bonuses, as well, just quickly mentioning that there is wagering requirements.

I like your suggestions.

Quote from: Lady KHello dear Victor,

I know you've been busy and me I've been practicing. 
As Iggiv mentioned and I agree, this may work on some wheels (I think some "types" better than others). I never trusted RNG but I have been practicing with one as I can go at my own pace while learning. They keep throwing so many repeaters at me (which could be a different game, LoL) it's difficult sometimes. I used colored pencils yesterday to see the "layers" more clearly and actually got a hit that way. I can imagine what my casino would think if I were to walk in there and start coloring, haha. It is interesting though to see what part of the wheel is more active as the repeats tend to clump together. Do you ever bet the repeaters? And I would like to ask, which do you prefer for this method: live, airball, and/or RNG? 

I answered my own question about length of play, when I read your Zone Maximum post. On the 18 spins after the 37-cycle there are sometimes so many dots! You wrote if there are large contiguous areas already hit, to bet the "lesser ones". Do you mean the dots without repeats, or around the one dot that may be standing alone still?
Do you continue and try another 18 spins whether you've had a hit or not?
What is the least amount of numbers you have bet at one time... and the most...?

I appreciate your comment about not getting stuck on certain numbers... yeah, I was doing that.
As for misplacing a bet... been there, done that too. Never play when you're tired!
Also your comment about keeping my eyes open... I now try to be more aware of everything happening, and go with the flow of what the wheel is doing at that particular moment.   

I like watching the design the ball makes when moving from one part of the wheel to the other. Fascinating really. That must be possible to track somehow.

Great fun this!
K

Quote from: VLS
>> Look at how many people has gone broke because "it must show"

Cycle play protects you to a certain extent from the negative extreme situations, since you have a definitive point of exit, you aren't going to be suffering situations like chasing a double-street for 60+ spins pumping money after money on something that just isn't showing (ask F_LAT!).

By only continuing what is currently appearing, you protect from those.

Limited cycles also equal to limited mistakes too. In case you mess a bet, you aren't going to have to suffer a huge downfall in your bankroll, like it can be -for instance- to a heavy progression player misplacing a chip and not hitting a spin where he should; especially on the last steps of a heavy progression.

Treating each cycle as a separate gaming unit has its benefits over other strategies, specially when dealing with such type of extremes.