Quote from: Bayes on December 10, 2012, 08:04:08 AM
are you saying the framework will make bot coding easy?

Yes.

Creating a full blown long term testing suite with betting bot included is expected to be a VERY TRIVIAL TASK with it.

Simply a matter of receiving last number from the framework and passing it back a simple string, a la:

3@5|2@21|2@7-9

3 chips on number 5
2 chips on number 2
12 chips on street 7-9

The framework receives this text string and places the bet, creates the charts, etc. It's -well- a framework: an implementation of the core/base functionality for programmers to enjoy.

Programmers only need to care about using their favorite language in order to code very focused bet selection modules to interact with it. The rest of the functionality is being taken care of

Quote from: Bayes on December 10, 2012, 07:48:08 AM
but I don't do bots.

...Hopefully this gets to change with the framework some months from now

Max is on the alumni list, I'm certain you'll pick it up too.

...Interesting discussion dear Max, thanks for bringing it to the fore.

To me one number brings the opportunity for abrupt deviations from the mean, with wild swings.

It might be a blessing or a curse, depending on who you ask. But it does provide the "wildest" positive runs since the payout accompanies on the evening-out trams.

Remember roulette has "game duties", among which is to balance outcomes. Since one number is (physically) a hard target to hit, the game can miss a pocket during several cycles; but it must deliver as per its "duties" and then a single cycle MUST get more hits than expected when considering 37 individual spins in order to balance the ratios.

Here you "milk" it.

I'll try to accommodate it for a release somewhere this month.

This humble program is a workhorse programmed in C++

[attachimg=2]

Download: [attachmini=1]

It takes a file with roulette numbers (one per line) and outputs:

<file>-dozens.txt
<file>-dozens-debug.txt
<file>-columns.txt
<file>-columns-debug.txt

Even Gigabyte files are welcomed by it

Enjoy! 
Vic

#include <windows.h>
#include <fstream>
#include <deque>
#include <string>

// Identifiers.
#define IDC_BUTTON 2000

// Globals
HINSTANCE instance;
HWND hwnd;
HFONT h_font;
std::deque<int> dozens; // Deque as LIFO queue for dozens
std::deque<int> columns; // Deque as LIFO queue for columns

// Prototypes
int GetDozen(int num);
int GetColumn(int num);

// Declare window procedure
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

// Class name as global
char szClassName[ ] = "LastDCGen";

// Program's entrypoint
int WINAPI WinMain (HINSTANCE hThisInstance, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFunsterStil)
{
    instance = hThisInstance;
    MSG messages;
    WNDCLASSEX wincl;

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;
    wincl.style = CS_DBLCLKS;
    wincl.cbSize = sizeof (WNDCLASSEX);
    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;
    wincl.cbClsExtra = 0;
    wincl.cbWndExtra = 0;
    /* Use Windows's default color as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
               0,
               szClassName, /* Classname */
               "LastDC Lw Generator",  /* Title Text */
               WS_OVERLAPPEDWINDOW &~ WS_MAXIMIZEBOX &~ WS_MINIMIZEBOX, /* no min/max button */
               CW_USEDEFAULT,
               CW_USEDEFAULT,
               190, /* Width */
               100, /* Height */
               HWND_DESKTOP, /* The window is a child-window to desktop */
               NULL, /* No menu */
               hThisInstance,  /* Program Instance handler */
               NULL
           );

    // Center it
    RECT rc;
    int screenWidth = GetSystemMetrics(SM_CXSCREEN);
    int screenHeight = GetSystemMetrics(SM_CYSCREEN);
    GetWindowRect(hwnd, &rc);
    SetWindowPos(hwnd, 0, (screenWidth - rc.right)/2, (screenHeight - rc.bottom)/2, 0, 0, SWP_NOZORDER|SWP_NOSIZE);

    // Set Font
    h_font = CreateFont(-13, 0, 0, 0, FW_NORMAL, 0,
                        0, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                        DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Times New Roman");

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nFunsterStil);

    /* Run the message loop. */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);

        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}

// Window Procedure
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    // Handle messages
    switch (message)
    {

        // Form creation
    case WM_CREATE:

        // Create button
        HWND wnd;
        wnd = CreateWindowEx(0x00000000, "Button", "Select file", 0x50010001, 8, 16, 96, 32, hwnd, (HMENU) IDC_BUTTON, instance, NULL);
        SendMessage(wnd, WM_SETFONT, (WPARAM) h_font, TRUE);

        // Emulate button press
        break;

        // Handle user command
    case WM_COMMAND:
        switch (wParam)
        {
        case IDC_BUTTON:
            // Open file name
            OPENFILENAME ofn;

            // Memory buffer to contain file name
            char szFile[MAX_PATH+1];

            // Open file dialog
            ZeroMemory( &ofn , sizeof( ofn));
            ofn.lStructSize = sizeof ( ofn );
            ofn.hwndOwner = NULL ;
            ofn.lpstrFile = szFile ;
            ofn.lpstrFile[0] = '\0';
            ofn.nMaxFile = sizeof( szFile );
            ofn.lpstrFilter = "All\0*.*\0Text\0*.TXT\0";
            ofn.nFilterIndex =1;
            ofn.lpstrFileTitle = NULL ;
            ofn.nMaxFileTitle = 0 ;
            ofn.lpstrInitialDir=NULL ;
            ofn.Flags = OFN_PATHMUSTEXIST|OFN_FILEMUSTEXIST ;

            // Invoke file dialog
            if (GetOpenFileName( &ofn ))
            {
                // ifstream from file
                std::ifstream file(ofn.lpstrFile);

                // base name
                std::string ofbase;

                // Set base to opened file
                ofbase = ofn.lpstrFile;

                // Remove extension
                if (ofbase.find(".")!=std::string::npos)
                {
                    ofbase.erase(ofbase.find_last_of("."), std::string::npos);
                }

                // Declare filenames passing base
                std::string ofdozn(ofbase); // dozens
                std::string ofdozdbn(ofbase); // dozens debug
                std::string ofcoln(ofbase); // columns
                std::string ofcoldbn(ofbase); // columns debug

                // Append to dozens file
                ofdozn.append("-dozens.txt");

                // Append to dozens debug
                ofdozdbn.append("-dozens_debug.txt");

                // Append to columns file
                ofcoln.append("-columns.txt");

                // Append to columns debug
                ofcoldbn.append("-columns_debug.txt");

                // ofstream to files
                std::ofstream ofdoz(ofdozn.c_str());
                std::ofstream ofdozdb(ofdozdbn.c_str());
                std::ofstream ofcol(ofcoln.c_str());
                std::ofstream ofcoldb(ofcoldbn.c_str());

                // string for line
                std::string s;

                // Walk file
                while (std::getline(file, s))
                {
                    // Resize to two characters
                    s.resize(2);

                    // Halt if it isn't numeric
                    for (int i = 0; i < s.length(); ++i)
                    {
                        // Check
                        if (!isdigit(s[i]))
                        {
                            // skip iteration
                            continue;
                        }
                    }

                    // Set number
                    int number = atoi(s.c_str());

                    // Check it's 0-36 (roulette range)
                    if (number < 0 || number > 36)
                    {
                        // skip iteration
                        continue;
                    }

                    // Get current dozen
                    int dozen = GetDozen(number);

                    // Check if empty
                    if (dozens.size() == 0)
                    {
                        // Add element to deque's front
                        dozens.push_front(dozen);

                        // Skip iteration
                        continue;
                    }

                    // Look for an instance in deque
                    if (std::find(dozens.begin(), dozens.end(), dozen) != dozens.end())
                    {
                        // win to regular file
                        ofdoz << "W" << std::endl;

                        // win to debug file
                        ofdozdb << number << " " << dozen << " " << "W" << std::endl;
                    }
                    else
                    {
                        // lose
                        ofdoz << "L" << std::endl;

                        // lose to debug file
                        ofdozdb << number << " " << dozen << " " << "L" << std::endl;
                    }

                    // Handle one element
                    if (dozens.size() == 1 )
                    {
                        // Check for the same
                        if (dozen != dozens[0])
                        {
                            // Add second element to deque's front
                            dozens.push_front(dozen);
                        }

                        // Skip iteration
                        continue;
                    }

                    // Handle two elements
                    if (dozen != dozens[1])
                    {
                        // Pop first one
                        dozens.pop_back();

                        // Add new element to deque's front
                        dozens.push_front(dozen);
                    }

                    /* Columns */

                    // Get current column
                    int column = GetColumn(number);

                    // Check if empty
                    if (columns.size() == 0)
                    {
                        // Add element to deque's front
                        columns.push_front(column);

                        // Skip iteration
                        continue;
                    }

                    // Look for an instance in deque
                    if (std::find(columns.begin(), columns.end(), column) != columns.end())
                    {
                        // win to regular file
                        ofcol << "W" << std::endl;

                        // win to debug file
                        ofcoldb << number << " " << column << " " << "W" << std::endl;
                    }
                    else
                    {
                        // lose
                        ofcol << "L" << " " << std::endl;

                        // lose to debug file
                        ofcoldb << number << " " << column << " " << "L" << std::endl;
                    }

                    // Handle one element
                    if (columns.size() == 1 )
                    {
                        // Check for the same
                        if (column != columns[0])
                        {
                            // Add second element to deque's front
                            columns.push_front(column);
                        }

                        // Skip iteration
                        continue;
                    }

                    // Handle two elements
                    if (column != columns[1])
                    {
                        // Pop first one
                        columns.pop_back();

                        // Add new element to deque's front
                        columns.push_front(column);
                    }

                   
                }
               
                // Close ofstreams
                ofdoz.close();
                ofdozdb.close();
                ofcol.close();
                ofcoldb.close();
               
                // Clear deques
                dozens.clear();
                columns.clear();

                // Inform user we have processed everything
                MessageBox ( NULL , "Finished!" , "File Name" , MB_OK);
            }
        }

        break;

        // Form close
    case WM_DESTROY:

        // Launch BetSelection.cc
        ShellExecute(NULL, "open", "http://betselection.cc", NULL, NULL, SW_SHOWNORMAL);

        // Good bye!
        PostQuitMessage (0);
        break;

        // Process other messages
    default:
        return DefWindowProc (hwnd, message, wParam, lParam);
    }
    return 0;
}

/* Roulette Functions */

// Determines the dozen that a number belongs to
// Returns 0, 1, 2, 3.
int GetDozen(int num)
{
    switch (num)
    {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
        // First dozen
        return 1;
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
        // Second dozen
        return 2;
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
        // Third dozen
        return 3;
    default:
        // No dozen
        return 0;
    }
}


// Determines the column that a number belongs to
// Returns 0, 1, 2, 3.
int GetColumn(int num)
{
    switch (num)
    {
    case 1:
    case 4:
    case 7:
    case 10:
    case 13:
    case 16:
    case 19:
    case 22:
    case 25:
    case 28:
    case 31:
    case 34:
        // First column
        return 1;
    case 2:
    case 5:
    case 8:
    case 11:
    case 14:
    case 17:
    case 20:
    case 23:
    case 26:
    case 29:
    case 32:
    case 35:
        // Second column
        return 2;
    case 3:
    case 6:
    case 9:
    case 12:
    case 15:
    case 18:
    case 21:
    case 24:
    case 27:
    case 30:
    case 33:
    case 36:
        // Third column
        return 3;
    default:
        // No column
        return 0;
    }
}

Quote from: KingsRoulette on December 09, 2012, 04:28:21 PM
"Ralph's MSB"

I like it! 

It's OUR forum mon ami 

...I'm so glad to see *the* lady around

Quote from: Lady K on December 09, 2012, 12:36:23 PM
Chrisbis says to say Hi to Victor and everyone. He says he will be back one day. 

Hi back and most-excellent news! 


Send him our warmest hug

A final way to apply progressions is using the Parachute.

"Progressions are possible without increasing the bet"

This means that if I seek to win with #36, if I bet the double-street that contains it I’ll also earn in case any of the other five numbers is spun.

Instead of increasing the bet when I lose, I seek to increase the rate of risk and step down from playing double-street to playing a corner containing the number, as long as my bet shows at least one unit of profit in the event of a hit the betting remains the same, then moving to single street, spit and ultimately full straight-up number, always playing a single unit and always looking to make at least a chip.

By varying the amount of numbers followed by this methodology and the speed of evolution and involution of the bet one can get different game variations such as: ABC system, The 220 Goats, The HC3 and Manrique’s pointers system.

There are many progressions or progression-based strategies that bet more when winning more, and bet less or the same when they lose.

Reverse Labouchere, D'Alembert against, Guetting, reverse Beredsford and others. Again we say that a progression is not winning in itself if it’s not properly implemented.

Properly applying means applying a strategy together with bankroll management, according to a given selection criterion matching or giving to the betting progression support; to define it in its growth or decrements to parameters that are in-tune with the objectives.

It’s very easy to see what not to do, rather more difficult to see what must be done in this regard.

We may also combine progressions working jointly on playing opposite chances using only the resulting balances. A clear example of this is the implementation of D'Alembert against a chance and the Dutch to the contrary, giving gain when cycles of imbalance appear and balances close to neutral when balanced periods arise. With modest profit targets proportional to the risked bankroll they can be quite safe and reliable, although tedious in its application.

No progression or progression strategy can change the rate of play since winning the progression we are also paying the proportional tax.

However we will use progressions to try to optimize the results of the hits produced by a phenomenon met between specific bounded limits.

Almost all known systems used apply progression somewhere in which the imbalance is extended against us, then flat betting systems increase the bet by steps, betting at the same level throughout the duration of this step (each step can last same amount of balls -or not-, as  recommended by Marigny such as the ecart may accompany proportionally), aiming to a more and more pronounced imbalance which eventually returns to balance and to recover then when we need fewer winning bets.

If our strategy contemplated entering the game during the phase of a very unbalanced scenario and we are betting on the return of balance, any lost units are indicating that the imbalance worsened, making it more "favorable a priori" for the commitment to balance, then we drive up a notch to our bet.

Marigny recommended to go up a chip in the event of seven chips down when the initial deflection for a simple chance, expressed as isolated appearances or in series of elements, exceeded a 4-Ecart

Progressions:

Progressions, like hammers, are tools, and the tools themselves are neither good nor bad. A hammer can be used to chisel the Michelangelo or break any mother's head, or they can be used for any good or ill.

Always within a clear bankroll management strategy, the use of progressions can serve the purpose of limiting the time of recovery phases or amplifying positive cycles.

The limits to a recovery strategy based on progressions are to avoid falling into the childlike simplicity of trusting simply wagering more each time you lose would inexorably produce the recovery of the investment sometime. These systems, ultimately catastrophic, are extremely popular for their alleged logical end: “at some point I have to win and when I win I recover all”, so they say.

What they forget or do not know those who adhere to this logic is that sooner or later the unwelcome situation on which the series of losses is extended to such extent that it leaves the player without a bank, or we reach the table limit, or we could not get there in time to cover the 36 that was the number that recuperated the balance and precisely it’s what shows.

Relying on this is to rely on luck and to place us in the first group mentioned and deserves no further discussion.

Unfortunately playing this way most of the time you win, but as the players don’t put an appropriate and reasonable limit to assume a loss aiming to win in the overall balance, limited series of large losses will be high enough to become unrecoverable with long series of low profits.

Besides, violent progressions (I call violent those in which the stakes are always higher in each ball over the previous spin, but I do not open trial on their goodness or lack of it without putting it in context) produced a nervous state in the average player, which most can not tolerate even playing positive progressions and winning.

In the flat wagering application
(Equal mass, masse EGALE, massa pari)

They are betting that is always the same, uniformly, win or lose, until a positive balance of at least one unit.

As we never forget that we pay a tax on every play we do (especially when we won), we would have to find a situation conducive to bet, with some advantage to be expected within a reasonable period to make up for the famous tax.

Two types of games are based on this theory:

A1) Game of pointers
(Play for the imbalance)

I mean those numbers or those chances that appear more frequently than others. Playing in periods where the imbalance is evident, these games still win bets playing flat. The Law of the Third with all its limitations, which we will see, will be one of our tools.

In this case we refer to the deviations caused by the very nature of chance and not by external factors such as cylinder wear, table defects, etc. They deserve an annex themselves, anticipating from now these tools are difficult to develop because the casinos cater to permanently correct these slippages.

B1) Games of backwardness
(They are based on finding the balance)

We mean to play seeking delays with flat betting, until the number of units earned exceed the invested to achieve this. To develop this game our theoretical foundation will be the Balancing Act or Law of Large Numbers, and also the use of other tools such as the law of distribution of figures, and equations of deviation or Ecart or Scarto, which represent a statistically allowed return to equilibrium when an imbalance occurs.

Both the A1 and the B1 strategy are based on investing time instead of chips, ie require a longer or shorter period in which data are taken without betting.

Since this does not guarantee an expected win in 100% of cases, it's usually unfavorable to the very  impatient players or those with low resistance to frustration, making a wait to lose is not pleasant for anyone.
The truth is that opening a business and not having customers on a given day has the same effect, but is not as visible or makes the merchant leave what he's doing, since he's aware that the days of loss will be offset by the other days of gain.

The upside of these strategies is the relative tranquility with which it's played once an attack begins when the relatively fast and obtainable advantage shows itself to be enough to get the result of the day.

Most often, however, switching between few losses and gains by not having a clearly shown return to equilibrium manifesting markedly. Playing patiently, the advantage comes if we settle for the systematic accumulation of small gains that will take us to capitalize on significant figures in the medium term.

Now we'll roughly see the tools that we will build upon.

Quote from: TwoCatSam on December 08, 2012, 01:00:07 AM
Ralph is to be congratulated for his generosity!!

Indeed.

One big toast to him 

Personally, I believe great things can have humble origins.

Even the brightest posters were guests once; we can tip many of them to posting with this.