Нахождение детерминанта матрицы на С

[cerum]

Помогите пожалуйста написать программу для нахождения детерминанта матриц на основе рекурсивного алгоритма на языке С.
Написал такую программу

#include <conio.h> 
#include <stdio.h> 
#define n 4



int main (void)
{
	int Minor (int *ptr, int *ptr2, int nn, int row, int col);
	long int Determinant (int *ptr, int nn);

	long int det;
	//int i, j;
	int M[n][n] = {
		{3, 5, 7, 8},
		{-1, 7, 0, 1},
		{0, 5, 3, 2},
		{1, -1, 7, 4}
	};
	int *ptr;

	ptr = &M[0][0];
	
	det = Determinant (&M[0][0], n);
	printf("\n\t Determinant = %d", det);
	
	printf("\n\n Press any key: ");
	_getch();
	return 0;

}



int Minor (int *ptr, int *ptr2, int nn, int row, int col)
{
	int ki, kj, di = 0, dj;

	for (ki = 0; ki < nn - 1; ki++)
	{
		if (ki == row)
			di = 1;
		dj = 0;

		for (kj = 0; kj < nn - 1; kj++)
		{
			if (kj == col)
				dj = 1;
			*(ptr2 + ki*nn + kj) = *(ptr +(ki + di)*nn + (kj + dj)); 
		}
	}

}


long int Determinant (int *ptr, int nn)
{
	long int i, j, d = 0, k = 1;
	int R[n][n] = {0};
	int *ptr2, **ptr3;

	ptr2 = &R[0][0];
	ptr3 = &ptr;

	if (nn < 1)
		return 1;
	else if (nn == 1)
		d = *ptr;
	else if (nn == 2)
		d = *ptr * *(ptr + nn + 1) - *(ptr + nn) * *(ptr + 1);
	else 
		for (i = 0; i < nn; ++i)
		{
			Minor (*ptr3, &R[0][0], nn, i, 0);
			d += k * *(ptr + i*nn) * Determinant (&R[0][0], nn - 1);
			k = -k;
			
		}

	return d;

}

Если матрица больше чем 2х2, то не работает. Как ее исправить?

[BDA]

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

long int
det(int **ptr, int n, int row, unsigned free_col)
{
    if (row >= n) {
        return 1;
    }
    long int s = 0, k = 1;
    int i;
    for (i = 0; i < n; ++i) {
        if (!(free_col >> i & 1)) {
            s += k * ptr[row][i] * det(ptr, n, row + 1, free_col | (1 << i));
            k = -k;
        }
    }
    return s;
}

long int
Determinant(int **ptr, int n)
{
    return det(ptr, n, 0, 0);
}

int
main(void)
{
    srand(time(NULL));
    int n = 4;
    int **m = malloc(n * sizeof(*m));
    int i, j;
    for (i = 0; i < n; ++i) {
        m[i] = malloc(n * sizeof(**m));
        for (j = 0; j < n; ++j) {
            m[i][j] = rand() % 11 - 5;
            printf("%4d", m[i][j]);
        }
        printf("\n");
    }
    printf("\nDeterminant = %ld\n\nPress any key", Determinant(m, n));
    for (i = 0; i < n; ++i)
        free(m[i]);
    free(m);
    _getch();
    return 0;
}

Лучше немного поменять алгоритм.

[cerum]

BDA, большое спасибо за помощь. А вот эти фрагменты можно заменить чем-то более простым?

 if (!(free_col >> i & 1))

free_col | (1 << i))

Никак ни разберусь как они работают? С побитовыми операциями вообще только сейчас познакомился.
BDA, разъясни пожалуйста как эти две строки работают

[BDA]

Пожалуйста.
Как раз таки использование битовых операций наиболее просто, на мой взгляд (да и экономично - 4 байта для матриц до 32х32 включительно; матрицы с большим размером считать нельзя таким образом - нужно использовать больший беззнаковый тип).
free_col хранит 0 биты на тех местах, какие колонки еще не использованы для расчета.

if (!(free_col >> i & 1))
free_col >> i - сдвиг на i бит влево
free_col >> i & 1 - побитовое "И" c 1 (выделяется 1 бит из числа)
!(free_col >> i & 1) - если полученный бит нулевой, то условие выполняется

free_col | (1 << i))
1 << i - сдвиг 1 бита на i бит вправо
free_col | (1 << i)) - побитовое "ИЛИ" 2 чисел (таким образом, на i месте будет 1 бит)

[cerum]

BDA, не разберусь только со знаком > из следующей строки

if (row >= n)

= понятно зачем, благодаря нему определитель матрицы 1х1 равен самому числу, а вот зачем знак > не пойму, без него результат получается неверный. Разве есть такой момент выполнения программы, когда передаваемая строка будет больше размерности матрицы? Заранее спасибо

[BDA]

Наверное не может. Поставьте == вместо >= и протестируйте программу.

[cerum]

Сделал как вы советовали, теперь все отлично. BDA, большое спасибо за помощь!

[BDA]

Пожалуйста.
= - оператор присваивания
== - оператор сравнения