Solution to the differential equation: d2y/dx2 = -0.25 * x * x * y – a * y which is valid for all real and complex numbers. We examine the real solutions to the second order ordinary differential equations. See “Handbook of Mathematical Functions” by Milton Abramowitz and Irene A. Stegun, Chapter 19. Parabolic Cylinder functions. Page 686 Equation 19.2.7 Recurrence formula and 19.2.5 Series solutions.
I learned about the Laguerre and Legendre polynomials when I first read “Introduction to Quantum Mechanics” by Pauling and Wilson way back in the early 1970s. I later learned about the Chebyshev and other orthogonal polynomials. Beginning on March 30, 2015, I created yet another application to graph various orthogonal polynomials in C#. A few days ago, I wrote a Win32 C application to graph the Chebyshev, Laguerre, and Legendre orthogonal polynomials. At a later date, I will probably add Hermite and Jacobi polynomials.
// Romberg.cpp : Defines the entry point for the application.
// https://learn.microsoft.com/en-us/windows/win32/controls/create-a-simple-combo-box
#include "stdafx.h"
#include <CommCtrl.h>
#include <math.h>
#include <stdio.h>
#include "Romberg.h"
#define MAX_LOADSTRING 100
// Global Variables:
HINSTANCE hInst; // current instance
WCHAR szTitle[MAX_LOADSTRING]; // The title bar text
WCHAR szWindowClass[MAX_LOADSTRING]; // the main window class name
// Forward declarations of functions included in this code module:
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK RombergDialog(HWND, UINT, WPARAM, LPARAM);
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPWSTR lpCmdLine,
_In_ int nCmdShow)
{
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
// TODO: Place code here.
// Initialize global strings
LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadStringW(hInstance, IDC_ROMBERG, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// Perform application initialization:
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_ROMBERG));
MSG msg;
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0))
{
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int) msg.wParam;
}
//
// FUNCTION: MyRegisterClass()
//
// PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEXW wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ROMBERG));
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_ROMBERG);
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
return RegisterClassExW(&wcex);
}
//
// FUNCTION: InitInstance(HINSTANCE, int)
//
// PURPOSE: Saves instance handle and creates main window
//
// COMMENTS:
//
// In this function, we save the instance handle in a global variable and
// create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
hInst = hInstance; // Store instance handle in our global variable
HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
return TRUE;
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_COMMAND:
{
int wmId = LOWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case ID_OPTION_ROMBERGINTEGRATION:
DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), hWnd, RombergDialog);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
}
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
// TODO: Add any drawing code that uses hdc here...
EndPaint(hWnd, &ps);
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(lParam);
switch (message)
{
case WM_INITDIALOG:
return (INT_PTR)TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
{
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
}
break;
}
return (INT_PTR)FALSE;
}
double f0(double x)
{
return exp(-x * x);
}
double f1(double x)
{
return x * x;
}
double f2(double x)
{
double pi = 4.0 * atan(1.0);
return sin(101.0 * pi * x);
}
double f3(double x)
{
double pi = 4.0 * atan(1.0);
return 1.0 + sin(10.0 * pi * x);
}
double f4(double x)
{
return fabs(x - 1.0 / 3.0);
}
double f5(double x)
{
return sqrt(x);
}
double f6(double x)
{
double result = 1.0;
if (x != 0.0)
result = sin(x) / x;
return result;
}
/* https://en.wikipedia.org/wiki/Romberg%27s_method#Implementation */
char table[8192];
double R1[2048], R2[2048];
void print_row(size_t i, double* R)
{
char buffer[128];
sprintf_s(buffer, 128, "R[%2zu] = ", i);
strcat_s(table, 8192, buffer);
for (size_t j = 0; j <= i; ++j)
{
sprintf_s(buffer, 128, "%.*lf ", 16, R[j]);
strcat_s(table, 8192, buffer);
}
strcat_s(table, 8192, "\r\n");
}
double RombergExtrapolation(
double(*f)(double),
double a, double b,
size_t max_steps,
double acc)
{
double *Rp = &R1[0], *Rc = &R2[0];
double h = (b - a);
Rp[0] = (f(a) + f(b))*h*.5;
print_row(0, Rp);
for (size_t i = 1; i < max_steps; ++i)
{
h /= 2.;
double c = 0;
size_t ep = 1 << (i - 1);
for (size_t j = 1; j <= ep; ++j)
{
c += f(a + (2 * j - 1)*h);
}
Rc[0] = h*c + .5*Rp[0];
for (size_t j = 1; j <= i; ++j)
{
double n_k = pow(4, j);
Rc[j] = (n_k*Rc[j - 1] - Rp[j - 1]) / (n_k - 1);
}
print_row(i, Rc);
if (i > 1 && fabs(Rp[i - 1] - Rc[i]) < acc)
{
return Rc[i];
}
double *rt = Rp;
Rp = Rc;
Rc = rt;
}
return Rp[max_steps - 1];
}
INT_PTR CALLBACK RombergDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(lParam);
WORD word = LOWORD(wParam);
static TCHAR functions[7][128] =
{
TEXT("f(x) = exp(-x * x)"),
TEXT("f(x) = x * x"),
TEXT("f(x) = sin(101 * pi * x)"),
TEXT("f(x) = 1 + sin(10 * pi * x)"),
TEXT("f(x) = abs(x - 1.0 / 3.0)"),
TEXT("f(x) = sqrt(x)"),
TEXT("f(x) = sin(x) / x or 1 if x = 0")
};
static TCHAR A[1024];
static HWND cbWindow;
static int k = 0;
static int itemIndex;
switch (message)
{
case WM_INITDIALOG:
cbWindow = GetDlgItem(hDlg, IDC_COMBO1);
memset(&A, 0, sizeof(A));
for (k = 0; k < 6; k++)
{
// Add string to combobox.
SendMessage(cbWindow, CB_ADDSTRING, (WPARAM)k, (LPARAM)functions[k]);
}
// Send the CB_SETCURSEL message to display an initial item
// in the selection field
SendMessage(cbWindow, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);
return (INT_PTR)TRUE;
case WM_COMMAND:
if (word == IDOK || word == IDCANCEL)
{
EndDialog(hDlg, word);
return (INT_PTR)TRUE;
}
if (HIWORD(wParam) == CBN_SELCHANGE)
// If the user makes a selection from the list:
// Send CB_GETCURSEL message to get the index of the selected list item.
// Send CB_GETLBTEXT message to get the item.
// Display the item in a messagebox.
{
itemIndex = SendMessage((HWND)lParam, (UINT)CB_GETCURSEL,
(WPARAM)0, (LPARAM)0);
TCHAR listItem[256];
(TCHAR)SendMessage((HWND)lParam, (UINT)CB_GETLBTEXT,
(WPARAM)itemIndex, (LPARAM)listItem);
}
else if (word == IDC_BUTTON1)
{
char buffer[128];
GetDlgItemTextA(hDlg, IDC_EDIT1, buffer, 128);
double a = atof(buffer);
GetDlgItemTextA(hDlg, IDC_EDIT2, buffer, 128);
double b = atof(buffer);
double integral = 0.0;
GetDlgItemTextA(hDlg, IDC_EDIT4, buffer, 128);
double acc = atof(buffer);
int max_steps = GetDlgItemInt(hDlg, IDC_EDIT5, FALSE, FALSE);
switch (itemIndex)
{
case 0:
integral = RombergExtrapolation(f0, a, b, max_steps, acc);
break;
case 1:
integral = RombergExtrapolation(f1, a, b, max_steps, acc);
break;
case 2:
integral = RombergExtrapolation(f2, a, b, max_steps, acc);
break;
case 3:
integral = RombergExtrapolation(f3, a, b, max_steps, acc);
break;
case 4:
integral = RombergExtrapolation(f4, a, b, max_steps, acc);
break;
case 5:
integral = RombergExtrapolation(f5, a, b, max_steps, acc);
break;
case 6:
integral = RombergExtrapolation(f6, a, b, max_steps, acc);
break;
}
sprintf_s(buffer, 128, "Integral = %.*lf\r\n", 16, integral);
strcat_s(table, 8192, buffer);
SetDlgItemTextA(hDlg, IDC_EDIT7, table);
}
else if (word == IDC_BUTTON3)
{
table[0] = '\0';
SetDlgItemTextA(hDlg, IDC_EDIT7, table);
}
}
return (INT_PTR)FALSE;
}
void DblAdd(int l, double* a, double* b, double* c)
{
_asm
{
mov eax, a; load a matrix address
mov ebx, b; load a matrix address
mov edi, c; load result address
mov edx, l; load matrix length
finit;
ll: fld qword ptr[eax];
fld qword ptr[ebx];
fadd;
fstp qword ptr[edi];
fwait;
add edi, 8;
add eax, 8;
add ebx, 8;
dec edx;
jnz ll;
}
}
void DblSub(int l, double* a, double* b, double* c)
{
_asm
{
mov eax, a; load a matrix address
mov ebx, b; load a matrix address
mov edi, c; load result address
mov edx, l; load matrix length
finit;
ll: fld qword ptr[eax];
fld qword ptr[ebx];
fsub;
fstp qword ptr[edi];
fwait;
add edi, 8;
add eax, 8;
add ebx, 8;
dec edx;
jnz ll;
}
}
void Add(int l, int* a, int* b, int* c)
{
_asm
{
mov eax, a; load a vector address
mov ebx, b; load a vector address
mov edi, c; load result address
mov edx, l; load vector length
ll : mov ecx, 0;
add ecx, [eax];
add ecx, [ebx];
mov[edi], ecx;
add edi, 4;
add eax, 4;
add ebx, 4;
add ecx, 4;
dec edx;
jnz ll;
}
}
void Sub(int l, int* a, int* b, int* c)
{
_asm
{
mov eax, a; load a vector address
mov ebx, b; load a vector address
mov edi, c; load result address
mov edx, l; load vector length
ll : mov ecx, 0;
add ecx, [eax];
sub ecx, [ebx];
mov[edi], ecx;
add edi, 4;
add eax, 4;
add ebx, 4;
add ecx, 4;
dec edx;
jnz ll;
}
}
// LongIntSum.cpp : Defines the entry point for the application.
// Translated from the Pascal code found in the textbook
// "Applied Data Structures Using Pascal" by Guy J. Hale and
// Richard J. Easton pages 98 and 99.
#include "stdafx.h"
#include "CharArrayStack.h"
#include "LongIntSum.h"
#define MAX_LOADSTRING 100
// Global Variables:
HINSTANCE hInst; // current instance
WCHAR szTitle[MAX_LOADSTRING]; // The title bar text
WCHAR szWindowClass[MAX_LOADSTRING]; // the main window class name
// Forward declarations of functions included in this code module:
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK AddDialog(HWND, UINT, WPARAM, LPARAM);
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPWSTR lpCmdLine,
_In_ int nCmdShow)
{
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
// TODO: Place code here.
// Initialize global strings
LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadStringW(hInstance, IDC_LONGINTSUM, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// Perform application initialization:
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_LONGINTSUM));
MSG msg;
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0))
{
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int) msg.wParam;
}
//
// FUNCTION: MyRegisterClass()
//
// PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEXW wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_LONGINTSUM));
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_LONGINTSUM);
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
return RegisterClassExW(&wcex);
}
//
// FUNCTION: InitInstance(HINSTANCE, int)
//
// PURPOSE: Saves instance handle and creates main window
//
// COMMENTS:
//
// In this function, we save the instance handle in a global variable and
// create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
hInst = hInstance; // Store instance handle in our global variable
HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
return TRUE;
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_COMMAND:
{
int wmId = LOWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case ID_FILE_LONGINTADDITION:
DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), hWnd, AddDialog);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
}
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
// TODO: Add any drawing code that uses hdc here...
EndPaint(hWnd, &ps);
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(lParam);
switch (message)
{
case WM_INITDIALOG:
return (INT_PTR)TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
{
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
}
break;
}
return (INT_PTR)FALSE;
}
#define BUFFER_MAX 8192
WCHAR buffer1[BUFFER_MAX];
WCHAR buffer2[BUFFER_MAX];
WCHAR buffer3[BUFFER_MAX];
CHARARRAYSTACK stack1;
CHARARRAYSTACK stack2;
CHARARRAYSTACK stack3;
void Add(
HWND hwnd,
int id1,
int id2,
int id3)
{
WCHAR ch1, ch2, ch3;
int carry = 0, i, i1, i2, i3, count = 0;
GetDlgItemText(hwnd, id1, buffer1, BUFFER_MAX);
GetDlgItemText(hwnd, id2, buffer2, BUFFER_MAX);
for (i = 0; i < (int)wcslen(buffer1); i++)
PushCharArrayStack(&stack1, buffer1[i]);
for (i = 0; i < (int)wcslen(buffer2); i++)
PushCharArrayStack(&stack2, buffer2[i]);
while (
!EmptyCharArrayStack(&stack1) &&
!EmptyCharArrayStack(&stack2))
{
PopCharArrayStack(&stack1, &ch1);
PopCharArrayStack(&stack2, &ch2);
i1 = (int)(ch1 - '0');
i2 = (int)(ch2 - '0');
i3 = i1 + i2 + carry;
carry = i3 / 10;
i3 %= 10;
ch3 = (char)(i3 + '0');
PushCharArrayStack(&stack3, ch3);
}
while (!EmptyCharArrayStack(&stack1))
{
PopCharArrayStack(&stack1, &ch1);
i1 = (int)(ch1 - '0');
i3 = i1 + carry;
carry = i3 / 10;
i3 %= 10;
ch3 = (char)(i3 + '0');
PushCharArrayStack(&stack3, ch3);
}
while (!EmptyCharArrayStack(&stack2))
{
PopCharArrayStack(&stack2, &ch2);
i2 = (int)(ch2 - '0');
i3 = i2 + carry;
carry = i3 / 10;
i3 %= 10;
ch3 = (char)(i3 + '0');
PushCharArrayStack(&stack3, ch3);
}
if (carry != 0)
{
ch3 = (char)(carry + '0');
PushCharArrayStack(&stack3, ch3);
}
while (!EmptyCharArrayStack(&stack3))
{
PopCharArrayStack(&stack3, &ch3);
buffer3[count++] = ch3;
}
buffer3[count] = '\0';
SetDlgItemText(hwnd, id3, buffer3);
}
// Message handler for long int addition dialog box.
INT_PTR CALLBACK AddDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(lParam);
WORD word = LOWORD(wParam);
switch (message)
{
case WM_INITDIALOG:
InitCharArrayStack(&stack1);
InitCharArrayStack(&stack2);
InitCharArrayStack(&stack3);
return (INT_PTR)TRUE;
case WM_COMMAND:
if (word == IDOK || word == IDCANCEL)
{
EndDialog(hDlg, word);
return (INT_PTR)TRUE;
}
if (word == IDC_BUTTON1)
Add(hDlg, IDC_EDIT1, IDC_EDIT2, IDC_EDIT3);
break;
}
return (INT_PTR)FALSE;
}
#pragma once
#include "stdafx.h"
#define STACK_SIZE 8192
typedef struct myCharArrayStack {
WCHAR data[STACK_SIZE];
int top;
} CHARARRAYSTACK, *PCHARARRAYSTACK;
void InitCharArrayStack(
PCHARARRAYSTACK stack);
BOOL EmptyCharArrayStack(
PCHARARRAYSTACK stack);
BOOL FullCharArrayStack(
PCHARARRAYSTACK stack);
BOOL PushCharArrayStack(
PCHARARRAYSTACK stack,
WCHAR data);
BOOL PopCharArrayStack(
PCHARARRAYSTACK stack,
WCHAR* data);
#include "stdafx.h"
#include "CharArrayStack.h"
void InitCharArrayStack(
PCHARARRAYSTACK stack)
{
int i;
for (i = 0; i < stack->top; i++)
stack->data[i] = '\0';
stack->data[0] = 0;
stack->top = -1;
}
BOOL EmptyCharArrayStack(
PCHARARRAYSTACK stack)
{
return stack->top == -1 ? TRUE : FALSE;
}
BOOL FullCharArrayStack(
PCHARARRAYSTACK stack)
{
return stack->top == STACK_SIZE - 1 ? TRUE : FALSE;
}
BOOL PushCharArrayStack(
PCHARARRAYSTACK stack,
WCHAR data)
{
BOOL result = FALSE;
if (!FullCharArrayStack(stack))
{
stack->top++;
stack->data[stack->top] = 0;
stack->data[stack->top] = data;
result = TRUE;
}
return result;
}
BOOL PopCharArrayStack(
PCHARARRAYSTACK stack,
WCHAR* data)
{
BOOL result = FALSE;
if (!EmptyCharArrayStack(stack))
{
*data = stack->data[stack->top];
stack->top--;
result = TRUE;
}
return result;
}
My history of developing artificially intelligent checkers applications began in the Winter Quarter of 1999 at Auburn University. I was taking a Machine Learning course taught by Professor Gerry V. Dozier. We used the textbook “Machine Learning” by Tom M. Mitchell. The first chapter of the now classic textbook is devoted to developing a framework for a checkers (draughts) game. Mitchell used an evaluation function with seven weights and a least mean squares training rule. Over the years I have expanded the number of weights to fourteen rules. I seem to recall my early efforts were in C and later Java. I began programming checkers and chess applications on a Palm Pilot in the Summer Semester of 2002 in the course Handheld Software Development taught by my PhD research advisor Professor Richard O. Chapman. This work was performed in Palm Pilot Operating System C programming language. I created a client server set of programs to operate over TCP/IP networks. I had a modem for my Palm Pilot and learned TCP/IP sockets programming on the Palm Pilot. I still have two volumes addressing Palm Pilot C programming. I created a C# checkers program beginning on October 19, 2017. I started creating a Win32 version of my C# application on October 27, 2022. Unfortunately, I cannot video capture a Win32 game using the Windows button followed by the letter G for Game Boy. The program has five dialogs and apparently Windows-G buttons do not record dialogs. You can find a video of the computer playing against the computer on my Facebook page. I show the main dialog of the Win32 application in this blog.
I am in the progress of translating (porting) my J. M. Pollard’s algorithm “Factoring with Cubic Integers” C# application to a Free LIP based vanilla C Windows 32-bit console application. The first phase of the method is to generate two factor bases namely a rational prime factor base and an algebraic integer prime factor base. I have included some preliminary results from this fast-moving computer programming task. I generated 2012 algebraic integer primes in about a minute and thirty seconds.
Numerical Explorations 