import java.math.BigDecimal;
import java.math.BigInteger;

public class Determinant {

	public static double det(double[][] a) {
		final double eps = 1e-10;
		int n = a.length;
		double res = 1;
		boolean[] used = new boolean[n];
		for (int i = 0; i < n; i++) {
			int p;
			for (p = 0; p < n; p++)
				if (!used[p] && Math.abs(a[p][i]) > eps)
					break;
			if (p == n)
				return 0;
			res *= a[p][i];
			used[p] = true;
			double z = 1 / a[p][i];
			for (int j = 0; j < n; j++)
				a[p][j] *= z;
			for (int j = 0; j < n; ++j)
				if (j != p) {
					z = a[j][i];
					for (int k = 0; k < n; ++k)
						a[j][k] -= z * a[p][k];
				}
		}
		return res;
	}

	public static BigInteger detCrout(BigDecimal a[][], int n) {
		try {
			for (int i = 0; i < n; i++) {
				boolean nonzero = false;
				for (int j = 0; j < n; j++)
					if (a[i][j].compareTo(new BigDecimal(BigInteger.ZERO)) > 0)
						nonzero = true;
				if (!nonzero)
					return BigInteger.ZERO;
			}

			BigDecimal scaling[] = new BigDecimal[n];
			for (int i = 0; i < n; i++) {
				BigDecimal big = new BigDecimal(BigInteger.ZERO);
				for (int j = 0; j < n; j++)
					if (a[i][j].abs().compareTo(big) > 0)
						big = a[i][j].abs();
				scaling[i] = (new BigDecimal(BigInteger.ONE)).divide(big, 100, BigDecimal.ROUND_HALF_EVEN);
			}

			int sign = 1;

			for (int j = 0; j < n; j++) {

				for (int i = 0; i < j; i++) {
					BigDecimal sum = a[i][j];
					for (int k = 0; k < i; k++)
						sum = sum.subtract(a[i][k].multiply(a[k][j]));
					a[i][j] = sum;
				}

				BigDecimal big = new BigDecimal(BigInteger.ZERO);
				int imax = -1;
				for (int i = j; i < n; i++) {
					BigDecimal sum = a[i][j];
					for (int k = 0; k < j; k++)
						sum = sum.subtract(a[i][k].multiply(a[k][j]));
					a[i][j] = sum;
					BigDecimal cur = sum.abs();
					cur = cur.multiply(scaling[i]);
					if (cur.compareTo(big) >= 0) {
						big = cur;
						imax = i;
					}
				}

				if (j != imax) {

					for (int k = 0; k < n; k++) {
						BigDecimal t = a[j][k];
						a[j][k] = a[imax][k];
						a[imax][k] = t;
					}

					BigDecimal t = scaling[imax];
					scaling[imax] = scaling[j];
					scaling[j] = t;

					sign = -sign;
				}

				if (j != n - 1)
					for (int i = j + 1; i < n; i++)
						a[i][j] = a[i][j].divide(a[j][j], 100, BigDecimal.ROUND_HALF_EVEN);

			}

			BigDecimal result = new BigDecimal(1);
			if (sign == -1)
				result = result.negate();
			for (int i = 0; i < n; i++)
				result = result.multiply(a[i][i]);

			return result.divide(BigDecimal.valueOf(1), 0, BigDecimal.ROUND_HALF_EVEN).toBigInteger();

		} catch (Exception e) {
			return BigInteger.ZERO;
		}
	}

	public static BigInteger detBigInteger(long[][] a) {
		int n = a.length;
		BigInteger[][] b = new BigInteger[n][n];
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				b[i][j] = BigInteger.valueOf(a[i][j]);

		int sign = 1;
		int[] pow = new int[n];
		for (int i = 0; i < n; ++i) {
			int k = i;
			for (int j = i + 1; j < n; ++j) {
				if (b[k][i].equals(BigInteger.ZERO) || !b[j][i].equals(BigInteger.ZERO)
						&& b[k][i].abs().compareTo(b[j][i].abs()) > 0) {
					k = j;
				}
			}
			if (b[k][i].equals(BigInteger.ZERO))
				return BigInteger.ZERO;
			if (i != k) {
				sign = -sign;
				BigInteger[] t = b[i];
				b[i] = b[k];
				b[k] = t;
			}
			++pow[i];
			for (int j = i + 1; j < n; ++j)
				if (!b[j][i].equals(BigInteger.ZERO)) {
					for (int p = i + 1; p < n; ++p) {
						b[j][p] = b[j][p].multiply(b[i][i]).subtract(b[i][p].multiply(b[j][i]));
					}
					--pow[i];
				}
		}
		BigInteger det = BigInteger.ONE;
		for (int i = 0; i < n; i++)
			if (pow[i] > 0)
				det = det.multiply(b[i][i].pow(pow[i]));
		for (int i = 0; i < n; i++)
			if (pow[i] < 0)
				det = det.divide(b[i][i].pow(-pow[i]));
		if (sign < 0)
			det = det.negate();
		return det;
	}

	// Usage example
	public static void main(String[] args) {
		check(new long[][] { { 2, 4, 3, 5, 4 }, { 5, 4, 0, 2, 4 }, { 0, 5, 5, 2, 3 }, { 1, 0, 4, 3, 0 },
				{ 0, 5, 1, 4, 4 } });
		check(new long[][] { { 3, 2, 2 }, { 0, 0, 5 }, { 4, 3, 1 } });
		check(new long[][] { { 2, 2, 2 }, { 1, 2, 0 }, { 2, 2, 0 } });
		check(new long[][] { { 1, 2 }, { 3, 4 } });
		check(new long[][] { { 2, 4 }, { 0, 3 } });
	}

	private static void check(long[][] a1) {
		int n = a1.length;
		double[][] a2 = new double[n][n];
		BigDecimal[][] a3 = new BigDecimal[n][n];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				a2[i][j] = a1[i][j];
				a3[i][j] = BigDecimal.valueOf(a1[i][j]);
			}
		}
		double res1 = det(a2);
		BigInteger res2 = detCrout(a3, n);
		BigInteger res3 = detBigInteger(a1);
		System.out.println(res1 + " " + res2 + " " + res3);
	}
}