here's a function I wrote to calculate a determinant of any order recursively. Just in case you needed one.

Code:
TFloatArray = array of Extended;
T2DFloatArray = array of TFloatArray;

// solve a determinant of any order
function Determinant(ADet : T2DFloatArray) : Extended;
Var
  LCol, LRow, LOrder, LNewOrder : Integer;
  LSign : boolean;
  LMinor : T2DFloatArray;
begin
  LOrder := length(ADet);

  if LOrder = 2 then begin

    // return the result
    Result := ADet[0][0] * ADet[1][1] - ADet[0][1] * ADet[1][0];

  end else begin

    // reduce the determinant by minors and solve determinants recursively
    LNewOrder := LOrder - 1;

    // create first minor
    SetLength(LMinor, LNewOrder);
    for LRow := 0 to LNewOrder - 1 do begin
      SetLength(LMinor[LRow], LNewOrder);
      for LCol := 0 to LNewOrder - 1 do
        LMinor[LRow][LCol] := ADet[LRow+1][LCol+1];
    end;

    // solve first minor
    Result := ADet[0][0] * Determinant(LMinor); 

    LSign := False; // negative

    // solve remaining minors and accumulate result
    for LCol := 1 to LNewOrder do begin

      // create the minor for this column by modifying the previous minor
      for LRow := 1 to LNewOrder do
        LMinor[LRow-1][LCol-1] := ADet[LRow][LCol-1];

      // accumulate terms to get result
      if LSign then Result := Result + ADet[0][LCol] * Determinant(LMinor)
               else Result := Result - ADet[0][LCol] * Determinant(LMinor);
               
      LSign := not LSign; // alternate sign of terms

    end; // minor columns loop

  end;
end;