BCX Basic Forum

MrBcx
the more recent gcc toolchainns have much better warning and error reporting, if you try the example with gcc-13.2 or above you will see the error message
<edit>
are you using llvm-g++?
llvm g++ simply calls clang and clang does not report the pragma inside a function as an error but simply ignores it
you need to use an non-llvm g++ 13.2 or better, but I won't bother you anymore

using clang with atomic I get
Time for             recursive:       1349
Time for      divide-iterative:       1350
Time for    multiply-iterative:       1114
Time for         if-statements:       1130
Time for reverse-if-statements:       1177
Time for                log-10:       3860
Time for           binary chop:       1256
if instead of atomic I do
only the main function from Robert's code posted below with the addition of a pragma
#pragma clang optimize off
int main (int c, char *v[]) {
//  _Atomic int i, j, k, r;
    int i, j, k, r;
    int s = 1;

    /* Test code:
        printf ("%11d %d\n", INT_MIN, count_recur(INT_MIN));
        for (i = -1000000000; i != 0; i /= 10)
            printf ("%11d %d\n", i, count_recur(i));
        printf ("%11d %d\n", 0, count_recur(0));
        for (i = 1; i != 1000000000; i *= 10)
            printf ("%11d %d\n", i, count_recur(i));
        printf ("%11d %d\n", 1000000000, count_recur(1000000000));
        printf ("%11d %d\n", INT_MAX, count_recur(INT_MAX));
    */

    /* Randomize and create random pool of numbers. */

    srand (time (NULL));
    for (j = 0; j < numof (rndnum); j++) {
        rndnum[j] = s * rand();
        s = -s;
    }
    rndnum[0] = INT_MAX;
    rndnum[1] = INT_MIN;

    /* For testing. */
    for (k = 0; k < numof (rndnum); k++) {
        rt[k] = (fn[1].fnptr)(rndnum[k]);
    }

    /* Test each of the functions in turn. */

    clk[0] = clock();
    for (i = 1; i < numof (fn); i++) {
        for (j = 0; j < 10000; j++) {
            for (k = 0; k < numof (rndnum); k++) {
                r = (fn[i].fnptr)(rndnum[k]);
                /* Test code:
                    if (r != rt[k]) {
                        printf ("Mismatch error [%s] %d %d %d %d\n",
                            fn[i].desc, k, rndnum[k], rt[k], r);
                        return 1;
                    }
                */
            }
        }
        clk[i] = clock();
    }

    /* Print out results. */

    for (i = 1; i < numof (fn); i++) {
        printf ("Time for %s: %10d\n", fn[i].desc, (int)(clk[i] - clk[i-1]));
    }

    return 0;
}
my time is
Time for             recursive:        658
Time for      divide-iterative:        566
Time for    multiply-iterative:        438
Time for         if-statements:        519
Time for reverse-if-statements:        502
Time for                log-10:       2730
Time for           binary chop:        487
unfortunately pragmas can not be used inside a function

you cal also use __attribute__ ((optnone)) but I prefer the pragma, it's cleaner syntax and you can also turn optimize back on with #pragma clang optimize on

here are my times
clang non-atomic, clang from https://github.com/mstorsjo/llvm-mingw/releases
Time for             recursive:          0
Time for      divide-iterative:          0
Time for    multiply-iterative:          0
Time for         if-statements:          0
Time for reverse-if-statements:          0
Time for                log-10:         78
Time for           binary chop:          0
atimic
Time for             recursive:       1349
Time for      divide-iterative:       1350
Time for    multiply-iterative:       1114
Time for         if-statements:       1130
Time for reverse-if-statements:       1177
Time for                log-10:       3860
Time for           binary chop:       1256
g++ 13.2 non-atomic -O2 , g++ from https://winlibs.com/
Time for             recursive:        548
Time for      divide-iterative:        487
Time for    multiply-iterative:        471
Time for         if-statements:        377
Time for reverse-if-statements:        423
Time for                log-10:       1287
Time for           binary chop:        393
I don't like the atomic times, they are about 2 times slower than g++
am also surprised that g++ didn't eliminate the loops

I think that I figured it out, it is in the RunCon64.bat but
%BCX%\bc %1 -cpp 1>bcxout.txt
also needed to edit gc64.bat to compile %1.cpp istead of %1.c, other bat files need editing

no, I was hoping that Jos would provide it and hopefully pscore5.dll doesn't have other dependencies

I looked at the headers provided in your link and to me a C beginner looks confusing, the function BTRCALL would be defined like the following in FreeBasic
function BTRCALL(byval operation as BTI_WORD, byval posBlock as BTI_VOID_PTR, byval dataBuffer as BTI_VOID_PTR, byval dataLength as BTI_WORD_PTR, byval keyBuffer as BTI_VOID_PTR, byval keyLength as BTI_BYTE, byval ckeynum as BTI_CHAR) as BTI_API

in BTITYPES.H BTI_WORD is defined as
typedef BTI_WORD  BTI_FAR* BTI_WORD_PTR;

I don't know how to parse "typedef BTI_WORD  BTI_FAR* BTI_WORD_PTR;", is BTI_WORD a BTI_FAR pointer? or does it boil down to a VOID ptr?
either way, I am not confident that all the parameters in your function declaration are correct

MrBcx
how do change the background color?
on my PC the balls move jittery but if I change TimerID = SetTimer(Form1, ID_TIMER, 50, NULL) from 50 to 30 then the balls move smoothly though quite a bit faster, but the black background makes it hard to distinguish the contour of the balls thereby making them look fuzzy

👍