Thanks for the interest, I'll make some time to drive an example with illustrations up.

The double trio isn't that much of a difficult pattern to grasp once you see it highlighted 

http://uxsoftware.com


Hopefully someone from UX staff gets to register around 

First one:
Somebody invite Kimo Li! 

Hey guys, since this is a tight community I thought about making a "somebody invite" thread, for missed members of the community.

I'll be pleased to upgrade missed members who register.

If any of you maintain contact with any of the mentioned members, talk to him/her about this place.

The fellow member might enjoy us and be grateful, as much as we will for you to sharing our humble space.

You must feed the program a properly formatted file:

- One number per line.

- No blanks/white-spaces.

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