Проблема с калькулятором для матриц на С

[Nitrino]

Держи писал когда то программу работающую с матрицами
Вычисляется вот такое выражение
([A]*[B]^2+[A]T*P)^3
Только тут работа с комплексными числами, если понадобится могу поискать, где то должна быть эта же программа для обычных чисел

/*Выполнил: Степченко Пётр (Nitrino)
  ([A]*[B]**2+[A]T*P)**3 
*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <conio.h>

typedef struct complex
{
	double a;
	double b;
};


//Выделение памяти
void *Malloc (size_t size)
{
		void *p=malloc(size);
		if (!p)
			 {
				printf("Недостаточно памяти\n");
				exit(1);
			 }
		return p;
}


//Конструктор матрицы
complex **MakeMatr(size_t n)
{
		complex **Matr;
		size_t i;
		Matr=(complex**)Malloc(sizeof(size_t)+n*sizeof(complex *));
		(size_t *)Matr+=1;
		for(i=0; i < n; i++)
			 Matr[i]=(complex *)Malloc(n*sizeof(complex));
		*((size_t *)Matr-1)=n;
		return Matr;
}

//
size_t GetN(complex **Matr)
{
		return *((size_t *)Matr-1);
}

//Заполнение матрицы
void RandMatr(complex **Matr)
{
		int i, j;
		size_t n=GetN(Matr);
		for (i=0; i < n; i++)
			 for (j=0; j < n; j++)
					{
						Matr[i][j].a=random(10);
						Matr[i][j].b=random(10);
					}
}

//Вывод матрицы
void OutMatr(char *name, complex **Matr)
{
		int i, j;
		size_t n=GetN(Matr);
		textcolor(10);
		cprintf("\nМатрица %s\n\r", name);
		for (i=0; i < n; i++)
		{
			 for (j=0; j < n; j++)
					printf("%9.1lf+%1.lfi  ", Matr[i][j].a, Matr[i][j].b);
			 printf("\n");
		}
}

//Деструктор матрицы
void DelMatr(complex **Matr)
{
		size_t i, n=GetN(Matr);
		for (i=0; i < n; i++) free(Matr[i]);
		free((size_t *)Matr-1);
}

//Заполнение матрицы нулевыми значениями
void NullMatr(complex **Matr)
{
		int i, j;
		size_t n=GetN(Matr);
		for (i=0; i < n; i++)
			 for (j=0; j < n; j++)
					{
						Matr[i][j].a=0.0;
						Matr[i][j].b=0.0;
					}
}

//----------------------------------------------------------------------------
//Умножение двух матриц
complex **Multiply(complex **Result, complex **Matr, complex **Matr2)
{
		int i, j, k;
		size_t n=GetN(Matr);
		for (i=0; i < n; i++)
			 for (j=0; j < n; j++)
					for (k=0; k < n; k++)
						 {
							Result[i][j].a+=Matr[i][k].a*Matr2[k][j].a-Matr[i][k].b*Matr2[k][j].b;
							Result[i][j].b+=Matr[i][k].b*Matr2[k][j].a+Matr[i][k].a*Matr2[k][j].b;
						 }
			return Result;

}

//----------------------------------------------------------------------------
//Умножение на число
complex **Const(complex **Matr, complex **Result, int p)
{
		int i, j;
		size_t n=GetN(Matr);
		for (i=0; i < n; i++)
			 for (j=0; j < n; j++)
					{
						Result[i][j].a=p*Matr[i][j].a;
						Result[i][j].b=p*Matr[i][j].b;
					}
		return Result;
}
//----------------------------------------------------------------------------
//Сложение матриц
complex **Plus(complex **Matr, complex **Matr2, complex **Result)
{
		int i, j;
		size_t n=GetN(Matr);
		for (i=0; i < n; i++)
			 for (j=0; j < n; j++)
					{
						Result[i][j].a=Matr[i][j].a+Matr2[i][j].a;
						Result[i][j].b=Matr[i][j].b+Matr2[i][j].b;
					}
		return Result;
}
//----------------------------------------------------------------------------
//возведение в степень
complex **Degree(complex **Matr, complex **Result, int a)
{
		int i, j;
		size_t n=GetN(Matr);
		complex **Result2;
		Result2=MakeMatr(n);


		for (i=0; i < n; i++)
			 for (j=0; j < n; j++)
					{
						Result[i][j].a=Matr[i][j].a;
						Result[i][j].b=Matr[i][j].b;
					}
		for (a--; a; a--)
		{
			 NullMatr(Result2);
			 Multiply(Result2, Result, Matr);
			 for (i=0; i < n; i++)
					for (j=0; j < n; j++)
						 Result[i][j]=Result2[i][j];
		}
		return Result2;
}

//----------------------------------------------------------------------------
//Транспонирование
complex **Transp(complex **Matr, complex **Result)
{
		int i, j;
		size_t n=GetN(Matr);
		

		for (i=0; i < n; i++)
			 for (j=0; j < n; j++)
					{
						Result[i][j].a=Matr[j][i].a;

					}

		return Result;
}


void main(void)
{
	 int n=2;
	 complex **A, **B, **C, **D;

	 clrscr();
	 randomize();

	 A=MakeMatr(n);
	 B=MakeMatr(n);
	 C=MakeMatr(n);
	 D=MakeMatr(n);
	 RandMatr(A);
	 RandMatr(B);

	 OutMatr("A", A);
	 OutMatr("B", B);

	 NullMatr(C);
	 C=Degree(B, C, 2);
	 Multiply(B, C, A);
	 NullMatr(C);
	 Transp(A, C);
	 Const(C, C, 2);
	 Plus(C, B, C);
	 D=Degree(C, D, 3);


	 OutMatr("D", D);

	 DelMatr(A);
	 DelMatr(B);
	 DelMatr(C);
	 DelMatr(D);

	 getch();
}