Переделать код с С на Windows Form

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
 
//Отладочная печать
//#define DEBUG
 
//Удобные определения, которых нет в C
#define bool unsigned char
#define true 1
#define false 0
 
//Тип "матрица"
typedef struct Matrix
{
    int rows; //строчек
    int columns; //столбцов
    int realrows; //Реально выделенных строк - для аккуратной работы с диспетчером памяти
    double ** data; //данные
} Matrix;
 
//Методы получения и записи данных
double get(Matrix * M, int row, int col)
{
    if (row >= M->rows) return 0;
    if (col >= M->columns) return 0;
    return M->data[row][col];
}
 
void set(Matrix * M, int row, int col, double value)
{
    if (row >= M->rows) return;
    if (col >= M->columns) return;
    M->data[row][col] = value;
}
 
long long TotalRAM = 0;
long long MaxRAM = 0;
int Created = 0;
long MULS = 0;
long ADDS = 0;
 
void RegRAM(int delta)
{
    TotalRAM += delta;
    if (MaxRAM < TotalRAM) MaxRAM = TotalRAM;
}
 
Matrix * Create(int rows,int columns)
//создать матрицу заданного размера
{
    Created++;
 
    if (rows == 0)
    {
        //printf("0 rows %d\n",Created);
    }
    if (columns == 0)
    {
        //printf("0 columns %d\n",Created);
    }
 
    int r,c;
    Matrix * Result = malloc(sizeof(Matrix));
    RegRAM(sizeof(Matrix));
    
    if (Result == NULL)
    {
        printf("Out of memory\n");
        getchar();
        return NULL;
    }
 
    Result->rows = rows;
    Result->columns = columns;
    //Простая защита от выделения 0 строк
    Result->realrows = Result->rows;
    if (Result->rows == 0) {
        Result->data = malloc(1 * sizeof(double*));
        Result->realrows = 1;
    } else
        Result->data = malloc(Result->rows * sizeof(double*));
 
    if (Result->data == NULL)
    {
        printf("Out of memory\n");
        getchar();
        return NULL;
    }
    RegRAM(Result->realrows * sizeof(double*));
    
    for (r = 0; r < Result->realrows; r++)
    {
        //Простая защита от нулевых запросов выделения памяти
        if (Result->columns == 0)
        {
            Result->data[r] = malloc(sizeof(double));
            RegRAM(sizeof(double));
        }
        else
        {
            RegRAM(Result->columns*sizeof(double));
            Result->data[r] = malloc(Result->columns*sizeof(double));
        }
        if (Result->data[r] == NULL)
        {
            printf("Out of memory\n");
            getchar();
            return NULL;
        }
    }
 
    for (r = 0; r < Result->rows; r++)
        for (c = 0; c < Result->columns; c++)
            Result->data[r][c] = 0; //На всякий случай
 
    return Result;
}
 
Matrix * Generate(int rows, int columns)
//Создать случайную матрицу
{
    int r, c;
    Matrix * Result = Create(rows, columns);
    for (r = 0; r < rows; r++)
        for (c = 0; c < columns; c++)
#ifdef DEBUG
            Result->data[r][c] = rand() % 10;
#else
            Result->data[r][c] = rand() % 1000 / 100.0;
#endif // DEBUG
    return Result;
}
 
void Delete(Matrix ** M)
//Освободить память
{
    if ((*M) == NULL)   return;
    RegRAM(-(*M)->columns*(*M)->realrows*sizeof(double) + (*M)->rows*sizeof(double*) + sizeof(Matrix));
    int r;
    for (r = 0; r < (*M)->realrows; r++) free((*M)->data[r]);
    free(*M);
    *M = NULL;
}
 
void Print(char * Head,Matrix * M, int width)
//Вывести на консоль или в файл
{
    int r, c;
    char Template[10];
    char FileName[80];
    FILE * F;
    if (!M) 
    {
        printf("No data %s\n",Head);
        return;
    }
    sprintf(Template, " %d.1f", width);
    Template[0] = '%';
    printf("%s [%dx%d]\n", Head, M->rows, M->columns);
 
    if (M->columns * width > 79)
    {
        sprintf(FileName, "%s.txt", Head);
        printf("Matrix %s is too large, saved to file \"%s\"\n", Head, FileName);
        F = fopen(FileName, "w");
        for (r = 0; r < M->rows; r++)
        {
            for (c = 0; c < M->columns; c++) fprintf(F,Template, M->data[r][c]);
            fprintf(F,"\n");
        }
        fclose(F);
        return;
    }
 
    for (r = 0; r < M->rows; r++)
    {
        for (c = 0; c < M->columns; c++) printf(Template, M->data[r][c]);
        printf("\n");
    }
}
 
#ifdef DEBUG
#define debugPrint(a,b,c) Print(a,b,c)
#else
#define debugPrint(a,b,c)
#endif
 
void mulStandart(Matrix *A, Matrix *B, Matrix * Result, int size, bool Fast)
//Умножение "стандартным" способом фрагментов матриц A&B размером size
//результат помещается в result
//dra итд - смещения внутри матриц
{
    //Для отчета
    int r, c, k;
    double S, TA, TB;
    for (r = 0; r < size; r++)
        for (c = 0; c < size; c++)
        {
            S = 0;
            for (k = 0; k < size; k++)
            {
                if (Fast)
                  S+=A->data[r][k]*B->data[k][c];
                else {
                        TA = get(A, r, k);
                        TB = get(B, k, c);
                        S += TA*TB;
                     }
                MULS++;
                ADDS++;
            }
            if (Fast)
              Result->data[r][c] = S;
            else
              set(Result, r, c, S);
        }
}
 
 
Matrix * MulStandart(Matrix *A, Matrix *B)
//Стандартное умножение
{
    int r, c, k;
    double S;
    Matrix * Result;
    if (!A || !B)
    {
        printf("No data\n");
        return NULL;
    }
    Result = Create(A->rows, B->columns);
 
    //Защита от некорректного размера
    if (A->columns != B->rows)
    {
        printf("Invalid matrix sizes\n");
        Delete(&Result);
        return NULL;
    }
 
    for (r = 0; r < Result->rows; r++)
        for (c = 0; c < Result->columns; c++)
        {
          S = 0;
          for (k = 0; k < A->columns; k++)
          {
              S += A->data[r][k] * B->data[k][c];
              MULS++;
              ADDS++;
          }
          Result->data[r][c] = S;
        }
    return Result;
}
 
bool Equals(Matrix *A, Matrix *B, double epsilon)
//Проверить совпадение двух матриц
{
    int r, c;
    if (!A) return false;
    if (!B) return false;
    if (epsilon < 0) epsilon = -epsilon;
    if (epsilon == 0) epsilon = 0.0000001;
    if (A->rows != B->rows) return false; //Не совпадают размеры
    if (A->columns != B->columns) return false; //Не совпадают размеры
    for (r = 0; r < A->rows; r++)
        for (c = 0; c < A->columns; c++)
            if (fabs(A->data[r][c] - B->data[r][c]) > epsilon) return false; //Большое различие!
    return true; //Все элементы почти одинаковы
}
 
//**************************************************************************//
 
int expand(int k)
//Найти ближайшую не меньшую k cтепень двойки
{
    if (k == 0) return 0;
    int result = 1;
    while (result < k) result <<= 1;
    return result;
}
 
void Copy(Matrix * From, Matrix * To, int size, int drfrom, int dcfrom, int drto, int dcto)
//Создать копию части матрицы в другой
//Размер фиксирован, матрица псевдоквадратная
{
    int r, c;
    double T;
    for (r = 0; r < size; r++)
        for (c = 0; c < size; c++)
        {
            T = get(From, r + drfrom, c + dcfrom);
            set(To, r+drto, c+dcto, T);
        }
}
 
void CopyTo(Matrix * From, Matrix * To, int drfrom, int dcfrom)
//Скопировать часть матрицы From в матрицу To
{
    int r, c;
    double T;
    for (r = 0; r < To->rows; r++)
        for (c = 0; c < To->columns; c++)
        {
            T = From->data[r+drfrom][c + dcfrom];
            To->data[r][c] = T;
        }
}
 
void CopyFrom(Matrix * From, Matrix * To, int drto, int dcto)
//Скопировать матрицу From в часть матрицы TO
{
    int r, c;
    double T;
    for (r = 0; r < From->rows; r++)
        for (c = 0; c < From->columns; c++)
        {
            T = From->data[r][c];
            To->data[r + drto][c + dcto] = T;
        }
}
 
 
void Add(Matrix * M, Matrix * To, bool Fast)
{
    int r, c;
    for (r = 0; r < M->rows; r++)
        for (c = 0; c < M->columns; c++)
            if (Fast)
                To->data[r][c] += M->data[r][c];
            else
                set(To,r,c,get(To,r,c)+ get(M,r,c));
}
 
void Sub(Matrix * M, Matrix * From, bool Fast)
{
    int r, c;
    for (r = 0; r < M->rows; r++)
        for (c = 0; c < M->columns; c++)
            if (Fast)
                From->data[r][c] -= M->data[r][c];
            else
                set(From, r, c, get(From, r, c) - get(M, r, c));
}
 
 void mulStrassen(Matrix *A, Matrix *B, Matrix * Result, int size, bool Fast)
//Перемножить методом Штрассена матрицы с фиктивным размером size
//Функция рекурсивная
//Проведем разбиение на "подматрицы"
// A         B
// A11 A12  B11 B12 
// A21 A22  B21 B22
{
    //При некотором size, меньшем заранее заданной величины, используется стандартный алгоритм умножения
    if (size < 4) //Не столько! Гораздо больше. 4 - в демонстрационных целях
    {
        mulStandart(A, B, Result, size, Fast);
        return;
    }
    //Иначе производится серия вычислений, описанных Штрассеном
    //Создается (это неизбежно) несколько матриц P
    //P1 = (A11+A22)*(B11+B22)
    //P2 = (A21+A22) * B11
    //P3 = A11 * (B12 - B22)
    //P4 = A22 * (B21 - B11)
    //P5 = (A11 + A12) * B22
    //P6 = (A21 - A11) * (B11+B12)
    //P7 = (A12 - A22) * (B21+B22)
 
    size /= 2;
    //Выделить четвертушки
 
    //P1 = (A11+A22)*(B11+B22)
    Matrix * A11 = Create(size, size); Copy(A, A11, size, 0, 0, 0, 0);
    Matrix * A22 = Create(size, size); Copy(A, A22, size, size, size, 0, 0);
    Matrix * T1 = Create(size, size); Copy(A11, T1, size, 0, 0, 0, 0);
    Add(A22, T1, Fast);
 
    Matrix * A12 = Create(size, size); Copy(A, A12, size, 0, size, 0, 0);
    Matrix * A21 = Create(size, size); Copy(A, A21, size, size, 0, 0, 0);
    Matrix * B11 = Create(size, size); Copy(B, B11, size, 0, 0, 0, 0);
    Matrix * B12 = Create(size, size); Copy(B, B12, size, 0, size, 0, 0);
    Matrix * B21 = Create(size, size); Copy(B, B21, size, size, 0, 0, 0);
    Matrix * B22 = Create(size, size); Copy(B, B22, size, size, size, 0, 0);
 
 
    Matrix * T2 = Create(size, size); Copy(B11, T2, size, 0, 0, 0, 0);
    Add(B22, T2, Fast);
    Matrix * P1 = Create(size, size); 
    mulStrassen(T1, T2, P1, size, true);
    //P2 = (A21+A22) * B11
    Matrix * P2 = Create(size, size);
    Copy(A21, T1, size, 0, 0, 0, 0);
    Add(A22, T1, Fast);
    mulStrassen(T1, B11, P2, size, true);
 
    //P3 = A11 * (B12 - B22)
    Matrix * P3 = Create(size, size);
    Copy(B12, T1, size, 0, 0, 0, 0);
    Sub(B22, T1, Fast);
    mulStrassen(A11, T1, P3, size, true);
    //P4 = A22 * (B21 - B11)
    Matrix * P4 = Create(size, size);
    Copy(B21, T1, size, 0, 0, 0, 0);
    Sub(B11, T1, Fast);
    mulStrassen(A22, T1, P4, size, true);
 
    //P5 = (A11 + A12) * B22
    Matrix * P5 = Create(size, size);
    Copy(A11, T1, size, 0, 0, 0, 0);
    Add(A12, T1, Fast);
    mulStrassen(T1, B22, P5, size, true);
    //P6 = (A21 - A11) * (B11+B12)
    Matrix * P6 = Create(size, size);
    Copy(A21, T1, size, 0, 0, 0, 0);
    Sub(A11, T1, Fast);
    Copy(B11, T2, size, 0, 0, 0, 0);
    Delete(&B11);
    Add(B12, T2, Fast);
    Delete(&A11);
    Delete(&A21);
    Delete(&B12);
    mulStrassen(T1, T2, P6, size, true);
 
    //P7 = (A12 - A22) * (B21+B22)
    Matrix * P7 = Create(size, size);
    Copy(A12, T1, size, 0, 0, 0, 0);
    Sub(A22, T1, Fast);
    Copy(B21, T2, size, 0, 0, 0, 0);
    Add(B22, T2, Fast);
    Delete(&A12);
    Delete(&A22);
    Delete(&B21); 
    Delete(&B22);
    mulStrassen(T1, T2, P7, size, true);
    Delete(&T2);
 
    //Тогда результирующая матрица будет образована так:
    //C11 = P1 + P4 - P5 + P7
    Copy(P1,T1,size,0,0,0,0);
    Add(P4, T1, Fast);
    Sub(P5, T1, Fast);
    Add(P7, T1, Fast);
    Delete(&P7);
    Copy(T1, Result, size, 0, 0, 0, 0);
    Delete(&T1); 
 
    //C12 = P3 + P5
    Add(P3,P5, Fast); //значение P5 больше не нужно 
    Copy(P5, Result, size, 0, 0, 0, size);
    Delete(&P5);
    //C21 = P2 + P4
    Add(P2,P4, Fast); //P4 не нужен
    Copy(P4, Result, size, 0, 0, size, 0);
    Delete(&P4);
 
    //C22 = P1 - P2 +P3 + P6
    Sub(P2, P1, Fast);
    Delete(&P2);
    Add(P3, P1, Fast);
    Delete(&P3);
    Add(P6, P1, Fast);
    Delete(&P6);
    Copy(P1,Result,size,0,0,size,size);
    Delete(&P1);
 
    //Освободить память
    }
 
Matrix * MulStrassen(Matrix *A, Matrix *B, bool Fast)
{
    int ra = expand(A->rows);
    int ca = expand(A->columns);
    int rb = expand(B->rows);
    int cb = expand(B->columns);
    int size = max(max(ra, rb), max(ca, cb));
    Matrix * Result = Create(A->rows, B->columns);
    mulStrassen(A, B, Result, size, Fast);
    return Result;
}
 
Matrix * MulMatrix(Matrix *A, Matrix *B)
{
    //Перемножение матриц смешанным способом.
    //Выделяется под матрица, годная для перемножения алгоритмом
    //Штрассена, и применяется формула
    //C1 C2
    //C3 C4 
    //C1 = A1*B1 + A2*B3
    //C2 = A2*B2 + A2*B1
    //C3 = A3*B1 + A4*B3
    //C4 = A3*B2 + A4*B4
 
    //Определить размеры
    int sizear = expand(A->rows); //Первой матрицы - строк
    int sizeac = expand(A->columns);
    int sizea = min(sizear, sizeac);
    int sizebr = expand(B->rows);
    int sizebc = expand(B->columns);
    int sizeb = min(sizebr, sizebc); //Копипаст - вреден для здоровья!
    int size = min(sizea, sizeb);
 
#ifdef DEBUG
    printf("Mul.size = %d\n", size);
#endif // DEBUG
 
    //Возможны случаи:
    //1. Обе матрицы квадратные и их размеры годные для Штрассена.
    //в этом случае все просто (и встречается не так редко, как может показаться)
    if (sizear == A->rows && sizeac == A->columns && sizear == sizeac
        && sizebr == B->rows && sizebc == B->columns && sizebr == sizebc
        && sizear == sizebr
        )
        return MulStrassen(A, B, true);
    //2. Матрицы маленькие. В этом случае лучше использовать стандартный способ умножения
    const int Small = 2; //На самом деле - примерно 32
    if (sizear <= Small || sizeac <= Small || sizebr <= Small || sizebc <= Small)
        return MulStandart(A, B);
    
    //Выбрать безопасный size
    while (size>A->rows) size /= 2;
    while (size>A->columns) size /= 2;
    while (size>B->rows) size /= 2;
    while (size>B->columns) size /= 2;
    //Свести к другим методам не получилось
    //Выделить матрицы
     //Из первой
    Matrix * A1 = Create(size, size);
    CopyTo(A, A1, 0, 0);
    debugPrint("A1", A1, 5);
    Matrix * B1 = Create(size, size);
    CopyTo(B, B1, 0, 0);
    debugPrint("B1", B1, 5);
    Matrix * C1 = MulMatrix(A1, B1);
 
    Matrix * A2 = Create(size, A->columns - size);
    CopyTo(A, A2, 0, size);
    debugPrint("A2", A2, 5);
 
    Matrix * B3 = Create(B->rows - size, size);
    CopyTo(B, B3, size, 0);
    debugPrint("B3", B3, 5);
 
    Matrix * T1 = MulMatrix(A2, B3);
    Add(T1, C1, true);
    debugPrint("C1", C1, 7);
    Delete(&T1);
 
    Matrix * A3 = Create(A->rows - size, size);
    CopyTo(A, A3, size, 0);
    debugPrint("A3", A3, 5);
 
    Matrix * A4 = Create(A->rows - size, A->columns - size);
    CopyTo(A, A4, size, size);
    debugPrint("A4", A4, 5);
 
    Matrix * B2 = Create(size, B->columns - size);
    CopyTo(B, B2, 0, size);
    debugPrint("B2", B2, 5);
 
    Matrix * B4 = Create(B->rows - size, B->columns - size);
    CopyTo(B, B4, size, size);
    debugPrint("B4", B4, 5);
 
    Matrix * C2 = MulMatrix(A1, B2);
    Delete(&A1);
 
    Matrix * T2 = MulMatrix(A2, B4);
    Delete(&A2);
 
    Add(T2, C2, true);
    debugPrint("C2", C2, 7);
    Delete(&T2);
 
    //Произвести вычисления
    Matrix * C3 = MulMatrix(A3, B1);
    Delete(&B1);
    Matrix * T3 = MulMatrix(A4, B3);
    Delete(&B3);
 
    Add(T3, C3, true);
    debugPrint("C3", C3, 7);
    Delete(&T3);
 
    Matrix * C4 = MulMatrix(A3, B2);
    Delete(&A3);
    Delete(&B2);
 
    Matrix * T4 = MulMatrix(A4, B4);
    Delete(&A4);
    Delete(&B4);
 
    Add(T4, C4, true);
    debugPrint("C4", C4, 7);
    Delete(&T4);
 
    //Собираем матрицу C
    Matrix * C = Create(A->rows, B->columns);
    CopyFrom(C1, C, 0, 0);
    debugPrint("C(C1)", C, 7);
    CopyFrom(C2, C, 0,size);//Уточнить размер
    debugPrint("C(C2)", C, 7);
    CopyFrom(C3, C, size,0);//Уточнить размер
    debugPrint("C(C3)", C, 7);
    CopyFrom(C4, C, size,size);//Уточнить размер
    debugPrint("C(C4)", C, 7);
    Delete(&C1); Delete(&C2); Delete(&C3); Delete(&C4);
    return C;
}
 
 
//**************************************************************************//
 
int main()
{
    srand((unsigned)time(0));
    int Arows=50,Acols=80,Bcols=50;
    printf("A.rows A.cols B.cols= ");
    scanf("%d %d %d", &Arows, &Acols, &Bcols);  getchar();
 
    if (Arows < 1) Arows = 1;
    if (Acols < 1) Acols = 1;
    if (Bcols < 1) Bcols = 1;
    Matrix * A = Generate(Arows,Acols);
    Matrix * B = Generate(Acols, Bcols); //A.cols==B.rows!
    Print("A", A, 5);
    Print("B", B, 5);
 
    //Matrix * C = MulStrassen(A, B, false);
    //Print("AB-Shtrassen",C,10);
    //if (!Equals(C, D, 0.00001)) printf("ERROR Shtrassen\n");
 
    clock_t T1 = clock();
    Matrix * D = MulStandart(A, B);
    int MULSS = MULS;
    int ADDSS = ADDS;
    MULS = 0;
    ADDS = 0;
    clock_t T2 = clock();
    Matrix * Z = MulMatrix(A, B);
    clock_t T3 = clock();
    Print("AB-Standart",D, 10);
    Print("AB-Mix", Z, 10);
    printf("\n");
    if (!Equals(D, Z, 0.00001)) printf("ERROR Mix\n");
    else
        printf("OK\n");
 
    if (MaxRAM<1024) printf("Max RAM = %lld bytes\n", MaxRAM);
    else if (MaxRAM<1024*1024) printf("Max RAM = %lld Kb\n", MaxRAM/1024);
    else if (MaxRAM<1024 * 1024 * 1024) printf("Max RAM = %lld Mb\n", MaxRAM / 1024/1024);
    else printf("Max RAM = %lld Gb\n", MaxRAM / 1024 / 1024 / 1024);
 
    printf("Standart MULS %d\n",MULSS);
//  printf("Standart ADDS %d\n", ADDSS);
    printf("Mix MULS %d\n", MULS);
//  printf("Mix ADDS %d\n", ADDS);
 
    int dT1 = (T2 - T1) * 1000 / CLK_TCK;
    int dT2 = (T3 - T2) * 1000 / CLK_TCK;
 
    printf("Standart Time = %d ms\n", dT1);
    printf("Mix Time = %d ms\n", dT2);
 
    getchar();
}